package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.*;
import com.wicket.okrapp.base.service.dto.req.*;
import com.wicket.okrapp.biz.service.*;
import com.wicket.okrapp.biz.service.dto.common.EvalThemeDto;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.RedisUtil;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerListComReqDto;
import com.wicket.okrframework.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

import com.wicket.okrapp.biz.service.dto.common.EvalTempDto;
import com.wicket.okrapp.biz.service.nb.NbEvaTheme;


import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrcomponent.integration.FwCompSchemeOpenRecordClient;
import com.wicket.okrapp.common.exception.Assert;

import java.util.ArrayList;

import com.wicket.okrframework.integration.FwBaseRoleClient;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrframework.integration.FwBasePowerClient;

import com.wicket.okrapp.biz.service.dto.common.ConfSchemeItemResultDto;
import com.wicket.okrapp.biz.service.dto.common.FrameworkSceneRoleDto;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrframework.integration.FwBaseBaseClient;

import java.util.concurrent.Callable;

import com.wicket.okrcomponent.integration.FwCompEvaThemeClient;
import com.wicket.okrframework.integration.FwBaseSecurityClient;


/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class EvaThemeServiceImpl implements com.wicket.okrapp.biz.service.EvaThemeService {
    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsEvaluationSubjectService mOmsEvaluationSubjectService;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
//@Resource
 //private MOmsConfSchemeOptionResultService mOmsConfSchemeOptionResultService;
@Resource
  private MOmsEvaluationPortraitService mOmsEvaluationPortraitService;
@Resource
  private MOmsEvaluationObjectService mOmsEvaluationObjectService;
@Resource
  private MOmsEvaluationFillRoleService mOmsEvaluationFillRoleService;
@Resource
  private NbEvaTheme nbEvaTheme;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private FwCompSchemeOpenRecordClient fwCompSchemeOpenRecordClient;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private FwBaseRoleClient fwBaseRoleClient;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
//@Resource
 //private MSpecMethordTableService mSpecMethordTableService;
@Resource
  private MOmsBizAppBatchService mOmsBizAppBatchService;
@Resource
  private OffStateService offStateService;
@Resource
  private PlanDataService planDataService;
@Resource
  private MOmsVirtualOrgService mOmsVirtualOrgService;
@Resource
  private MOmsVirtualOrgMemberDeptService mOmsVirtualOrgMemberDeptService;
@Resource
  private MOmsVirtualOrgMemberService mOmsVirtualOrgMemberService;
@Resource
  private FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  private FwBasePowerClient fwBasePowerClient;
@Resource
  private MOmsEvaluationFillMemberService mOmsEvaluationFillMemberService;
@Resource
  private BatchService batchService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private TaskGenService taskGenService;
@Resource
  private FwBaseBaseClient fwBaseBaseClient;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private MOmsBasicInstanceAssistBehaviorCurrentStepService mOmsBasicInstanceAssistBehaviorCurrentStepService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
@Resource
  private MOmsAssistNodeStatusService mOmsAssistNodeStatusService;
@Resource
  private TimingTaskService timingTaskService;
@Resource
  private FwCompEvaThemeClient fwCompEvaThemeClient;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private FwBaseSecurityClient fwBaseSecurityClient;
@Resource
  private CustomExecutionCycleService customExecutionCycleService;
@Resource
  private MOmsTaskService mOmsTaskService;
//@Resource
 //private MCustomFields2Service mCustomFields2Service;
//@Resource
//  private CustomExecutionCycleService customExecutionCycleService;


    /**
   * D3-2批量查询评价主题列表[2146]
   * gen by moon at 11/9/2022, 1:00:46 AM
   */
  @Trace(operationName = "D3-2批量查询评价主题列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryEvaThemeListRespDto batchQueryEvaThemeList(BatchQueryEvaThemeListReqDto reqDto){
    
      
      List<OmsEvaluationSubject> listOmsEvaluationSubject_1 =new ArrayList<>();
//步骤0: 3-2-02批量查询评价主题列表 - batchQueryEvaThemeList
     List<OmsEvaluationSubject> listOmsEvaluationSubject =new ArrayList<>();
    BatchQueryEvaThemeListReq batchQueryEvaThemeListReq=new BatchQueryEvaThemeListReq();
  if(reqDto!=null){
      batchQueryEvaThemeListReq.setEvalThemeList(reqDto.getEvalThemeList());//list-field-assign//sourceId:62418_1
batchQueryEvaThemeListReq.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:62417_1
batchQueryEvaThemeListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258695_1
    }
  
    /*3-2-02批量查询评价主题列表[2144]   */
    Assert.isNull(batchQueryEvaThemeListReq.getAscriptionSpaceId(),"D3-2批量查询评价主题列表-3-2-02批量查询评价主题列表-归属空间ID不能为空",false);
      listOmsEvaluationSubject = mOmsEvaluationSubjectService.batchQueryEvaThemeList(batchQueryEvaThemeListReq);
      

      listOmsEvaluationSubject_1 = listOmsEvaluationSubject;
    
BatchQueryEvaThemeListRespDto retData = new BatchQueryEvaThemeListRespDto();
  retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item -> BeanUtil.toBean(item, EvalThemeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:62422_1
  

  
  
return retData;
  }
/**
   * D3-2修改评价主题[3086]
   * gen by moon at 5/24/2023, 3:54:04 AM
   */
  @Trace(operationName = "D3-2修改评价主题")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateEvaThemeRespDto updateEvaTheme(UpdateEvaThemeReqDto reqDto){
    
      
      //virtualUsage D2-3查配置方案标识  40211
      QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
    QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto=new QueryConfSchemeDetailComReqDto();
  queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:900849_1_40211
  if(reqDto!=null){
      queryConfSchemeDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900830_1_40211
    }
  
    /*D2-3查配置方案标识[1981]   */
    Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(),"D3-2修改评价主题-D2-3查配置方案标识-配置方案ID 不能为空",false);
Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(),"D3-2修改评价主题-D2-3查配置方案标识-生命周期状态不能为空",false);
      queryConfSchemeDetailComRespDto = fwCompConfSchemeClient.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2-3查主题配置方案基础分组标准答案  40210
      QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("THEME_BASIC_SET_CLASS");//CUSTOM_CONVENTION//sourceId:900740_1_40210
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:900819_1_40210
if(reqDto!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900829_1_40210
    }

    /*D2-3查主题配置方案基础分组标准答案[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfSchemeId(),"D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-配置方案ID 不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-2修改评价主题-D2-3查主题配置方案基础分组标准答案-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;

      

//virtualUsage 3-2-01修改评价主题  19207
      boolean bOOLEAN ;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null&&queryConfSchemeDetailComRespDto !=null){
          OmsEvaluationSubject omsEvaluationSubject=new OmsEvaluationSubject();
  if(reqDto!=null){
      omsEvaluationSubject.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:104556_1_19207
omsEvaluationSubject.setEvaluationSubjectName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:104562_1_19207
omsEvaluationSubject.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900737_1_19207
omsEvaluationSubject.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:104559_1_19207
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      omsEvaluationSubject.setBizSceneCode(queryClassMatchResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:900735_1_19207
omsEvaluationSubject.setEvaluationSubjectTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:900736_1_19207
    }
if(queryConfSchemeDetailComRespDto!=null){
      omsEvaluationSubject.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:900738_1_19207
    }
  
    /*3-2-01修改评价主题[2280]   */
    Assert.isNull(omsEvaluationSubject.getEvaluationSubjectId(),"D3-2修改评价主题-3-2-01修改评价主题-评价主题ID不能为空",false);
      bOOLEAN = mOmsEvaluationSubjectService.updateEvaTheme(omsEvaluationSubject)/*vcase invoke 本地 method 方法调用;*/;
      
      

           }
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
        //if(D3-2修改评价主题.主体生命周期 等于 当前有效)  39964
  
OmsEvaluationSubject omsEvaluationSubject_1 = null;
    QueryEvaThemeDetailReq queryEvaThemeDetailReq=new QueryEvaThemeDetailReq();
if(reqDto!=null){
      queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:900877_1_40214
    }

    /*3-2-01查评价主题[2310]   */
    Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(),"D3-2修改评价主题-3-2-01查评价主题-评价主题ID不能为空",false);
      omsEvaluationSubject_1 = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;



AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null&&queryClassMatchResultToAnswerDetailComRespDto !=null&&omsEvaluationSubject_1 !=null){
          AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto=new AddOpenRecordAuthorizationComReqDto();
  addOpenRecordAuthorizationComReqDto.setApplexType("EVA_THEME");//sourceId:900865_1_40212
if(reqDto!=null){
      addOpenRecordAuthorizationComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:900855_1_40212
addOpenRecordAuthorizationComReqDto.setAuthType(reqDto.getAuthType());//SimpleFieldAssign//sourceId:900857_1_40212
addOpenRecordAuthorizationComReqDto.setAuthorizationNum(reqDto.getRemainingQty());//SimpleFieldAssign//sourceId:900858_1_40212
addOpenRecordAuthorizationComReqDto.setAuthUnit(reqDto.getAuthUnit());//SimpleFieldAssign//sourceId:900859_1_40212
addOpenRecordAuthorizationComReqDto.setStartTime(reqDto.getStartTime());//SimpleFieldAssign//sourceId:900860_1_40212
addOpenRecordAuthorizationComReqDto.setEndTime(reqDto.getEndTime());//SimpleFieldAssign//sourceId:900861_1_40212
addOpenRecordAuthorizationComReqDto.setIsMainConfScheme(reqDto.getIsMainConfScheme());//SimpleFieldAssign//sourceId:900862_1_40212
addOpenRecordAuthorizationComReqDto.setApplexId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:900866_1_40212
addOpenRecordAuthorizationComReqDto.setApplexName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:915057_1_40212
addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:900864_1_40212
    }
if(queryConfSchemeDetailComRespDto!=null){
      addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:900856_1_40212
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:932183_1_40212
    }
if(omsEvaluationSubject_1!=null){
      addOpenRecordAuthorizationComReqDto.setTenantSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:900863_1_40212
    }
  
    /*D2新增开通记录并授权(公共)[3102]   */
    Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-配置方案ID 不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-配置方案标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-是否主配置方案不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-开通对象类型编码不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-开通对象ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-租户空间ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(),"D3-2修改评价主题-D2新增开通记录并授权(公共)-主体生命周期不能为空",false);
      addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      

           }
      }
UpdateEvaThemeRespDto retData = new UpdateEvaThemeRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2批量查询评价模板[3074]
   * gen by moon at 11/9/2022, 1:00:53 AM
   */
  @Trace(operationName = "D3-2批量查询评价模板")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryEvaTempRespDto batchQueryEvaTemp(BatchQueryEvaTempReqDto reqDto){
    
      
      List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 =new ArrayList<>();
//步骤0: 3-2-02批量查询评价模板 - batchQueryEvaTemp
     List<OmsEvaluationTemplate> listOmsEvaluationTemplate =new ArrayList<>();
    BatchQueryEvaTempReq batchQueryEvaTempReq=new BatchQueryEvaTempReq();
  if(reqDto!=null){
      batchQueryEvaTempReq.setEvalTempList(reqDto.getEvalTempList());//list-field-assign//sourceId:104157_1
batchQueryEvaTempReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258697_1
    }
  
    /*3-2-02批量查询评价模板[3075]   */
    
      listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq);
      

      listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;
    
BatchQueryEvaTempRespDto retData = new BatchQueryEvaTempRespDto();
  retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item -> BeanUtil.toBean(item, EvalTempDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:104162_1
  

  
  
return retData;
  }
/**
   * D3-2查评价主题详情[2309]
   * gen by moon at 5/6/2023, 3:08:33 PM
   */
  @Trace(operationName = "D3-2查评价主题详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaThemeDetailRespDto queryEvaThemeDetail(QueryEvaThemeDetailReqDto reqDto){
    
      
      OmsEvaluationSubject omsEvaluationSubject_1 =null;
QueryConfResultNameUnconstrainedDetailComRespDto queryConfResultNameUnconstrainedDetailComRespDto_1 =null;
//步骤0: 3-2-01查评价主题详情 - queryEvaThemeDetail
     OmsEvaluationSubject omsEvaluationSubject = null;
    QueryEvaThemeDetailReq queryEvaThemeDetailReq=new QueryEvaThemeDetailReq();
  if(reqDto!=null){
      queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:68180_1
    }
  
    /*3-2-01查评价主题详情[2310]   */
    Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(),"D3-2查评价主题详情-3-2-01查评价主题详情-评价主题ID不能为空",false);
      omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      omsEvaluationSubject_1 = omsEvaluationSubject;
    
//步骤1: D2查询配置答案名称等无约束(公共) - queryConfResultNameUnconstrainedDetailCom
     QueryConfResultNameUnconstrainedDetailComRespDto queryConfResultNameUnconstrainedDetailComRespDto = null;
    if(omsEvaluationSubject !=null){
          QueryConfResultNameUnconstrainedDetailComReqDto queryConfResultNameUnconstrainedDetailComReqDto=new QueryConfResultNameUnconstrainedDetailComReqDto();
  queryConfResultNameUnconstrainedDetailComReqDto.setIsPlatData("FALSE");//sourceId:896142_1
if(omsEvaluationSubject!=null){
      queryConfResultNameUnconstrainedDetailComReqDto.setEndValue(omsEvaluationSubject.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:896139_1
queryConfResultNameUnconstrainedDetailComReqDto.setConfSchemeId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:896141_1
    }
if(reqDto!=null){
      queryConfResultNameUnconstrainedDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:896140_1
    }
  
    /*D2查评价主题类型名称[6483]   */
    Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getEndValue(),"D3-2查评价主题详情-D2查评价主题类型名称-答案值不能为空",false);
Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getResultAspObjId(),"D3-2查评价主题详情-D2查评价主题类型名称-答案归属对象ID不能为空",false);
Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getConfSchemeId(),"D3-2查评价主题详情-D2查评价主题类型名称-配置方案ID 不能为空",false);
Assert.isNull(queryConfResultNameUnconstrainedDetailComReqDto.getIsPlatData(),"D3-2查评价主题详情-D2查评价主题类型名称-是否标准答案不能为空",false);
      queryConfResultNameUnconstrainedDetailComRespDto = fwCompConfSchemeClient.queryConfResultNameUnconstrainedDetailCom(queryConfResultNameUnconstrainedDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryConfResultNameUnconstrainedDetailComRespDto_1 = queryConfResultNameUnconstrainedDetailComRespDto;
           }
    
QueryEvaThemeDetailRespDto retData = new QueryEvaThemeDetailRespDto();
  if(omsEvaluationSubject_1!=null){
      retData.setEvaluationSubjectId(omsEvaluationSubject_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:67872_1
retData.setEvaluationSubjectCode(omsEvaluationSubject_1.getEvaluationSubjectCode());//SimpleFieldAssign//sourceId:67873_1
retData.setEvaluationSubjectName(omsEvaluationSubject_1.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:67874_1
retData.setEvaluationSubjectTypeCode(omsEvaluationSubject_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:104596_1
retData.setBizSceneCode(omsEvaluationSubject_1.getBizSceneCode());//SimpleFieldAssign//sourceId:104597_1
retData.setConfSchemeId(omsEvaluationSubject_1.getConfSchemeId());//SimpleFieldAssign//sourceId:896144_1
retData.setConfSchemeCode(omsEvaluationSubject_1.getConfSchemeCode());//SimpleFieldAssign//sourceId:67875_1
retData.setAscriptionSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:374833_1
retData.setSubjectLifeCycle(omsEvaluationSubject_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:104598_1
retData.setOperationInductionId(omsEvaluationSubject_1.getOperationInductionId());//SimpleFieldAssign//sourceId:104599_1
retData.setOperateTime(omsEvaluationSubject_1.getOperateTime());//SimpleFieldAssign//sourceId:104600_1
    }
if(queryConfResultNameUnconstrainedDetailComRespDto_1!=null){
      retData.setEvaluationSubjectTypeName(queryConfResultNameUnconstrainedDetailComRespDto_1.getConfOptionName());//SimpleFieldAssign//sourceId:896143_1
    }
  

  
  
return retData;
  }
/**
   * D3-2查评价主题列表[2277]
   * gen by moon at 9/17/2022, 2:24:03 AM
   */
  @Trace(operationName = "D3-2查评价主题列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaThemeListRespDto queryEvaThemeList(QueryEvaThemeListReqDto reqDto){
    
      
      List<OmsEvaluationSubject> listOmsEvaluationSubject_1 =new ArrayList<>();
//步骤0: 3-2-01查评价主题列表 - queryEvaThemeList
     List<OmsEvaluationSubject> listOmsEvaluationSubject =new ArrayList<>();
    QueryEvaThemeListReq queryEvaThemeListReq=new QueryEvaThemeListReq();
  if(reqDto!=null){
      queryEvaThemeListReq.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//sourceId:66800_1
queryEvaThemeListReq.setBizSceneCode(reqDto.getBizSceneCode());//sourceId:67019_1
    }
  
    /*3-2-01查评价主题列表[2278]   */
    Assert.isNull(queryEvaThemeListReq.getAscriptionSpaceId(),"D3-2查评价主题列表-3-2-01查评价主题列表-归属空间ID不能为空",false);
      listOmsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeList(queryEvaThemeListReq);
      
      
      listOmsEvaluationSubject_1 = listOmsEvaluationSubject;

QueryEvaThemeListRespDto retData = new QueryEvaThemeListRespDto();
  retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item -> BeanUtil.toBean(item, EvalThemeDto.class)).collect(Collectors.toList()));//sourceId:66804_1
  

  
  
return retData;
  }
/**
   * D3-2新增评价主题[2118]
   * gen by moon at 5/24/2023, 3:53:57 AM
   */
  @Trace(operationName = "D3-2新增评价主题")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddEvaThemeRespDto addEvaTheme(AddEvaThemeReqDto reqDto){
    
      
      String string_1 =null;
AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto_1 =null;
String string_3 =null;
//virtualUsage D2-3查询配置方案详情(公共)  40073
      QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
    QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto=new QueryConfSchemeDetailComReqDto();
  queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:897082_1_40073
if(reqDto!=null){
      queryConfSchemeDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:897063_1_40073
    }

    /*D2-3查询配置方案详情(公共)[1981]   */
    Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(),"D3-2新增评价主题-D2-3查询配置方案详情(公共)-配置方案ID 不能为空",false);
Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(),"D3-2新增评价主题-D2-3查询配置方案详情(公共)-生命周期状态不能为空",false);
      queryConfSchemeDetailComRespDto = fwCompConfSchemeClient.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2-3查询分组匹配结果转答案(公共)(跨服务）  19196
      QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("THEME_BASIC_SET_CLASS");//CUSTOM_CONVENTION//sourceId:114491_1_19196
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:308501_1_19196
if(reqDto!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:894875_1_19196
    }
  
    /*D2-3查询分组匹配结果转答案(公共)(跨服务）[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfSchemeId(),"D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-配置方案ID 不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-2新增评价主题-D2-3查询分组匹配结果转答案(公共)(跨服务）-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      

//virtualUsage D1-2查空间详情(公共)  19232
      QuerySpaceDetailComRespDto querySpaceDetailComRespDto = null;
    QuerySpaceDetailComReqDto querySpaceDetailComReqDto=new QuerySpaceDetailComReqDto();
  if(reqDto!=null){
      querySpaceDetailComReqDto.setSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:375016_1_19232
    }
  
    /*D1-2查空间详情(公共)[402]   */
    Assert.isNull(querySpaceDetailComReqDto.getSpaceId(),"D3-2新增评价主题-D1-2查空间详情(公共)-空间ID不能为空",false);
      querySpaceDetailComRespDto = fwBaseBaseClient.querySpaceDetailCom(querySpaceDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
//virtualUsage M3业务应用公共字段推送内存  19233
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    if(querySpaceDetailComRespDto !=null){
          ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(querySpaceDetailComRespDto!=null){
      publicFieldCacheReq.setSpaceId(querySpaceDetailComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:375014_1_19233
publicFieldCacheReq.setAppId(querySpaceDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:375015_1_19233
    }
  
    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3-2新增评价主题-M3业务应用公共字段推送内存-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D3-2新增评价主题-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbEvaTheme.implementBizPublicFieldPushMemory(publicFieldCacheReq);
      
      
      
           }
//virtualUsage 3-2-02新增评价主题  19197
      String string = null;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null&&queryConfSchemeDetailComRespDto !=null){
          OmsEvaluationSubject omsEvaluationSubject=new OmsEvaluationSubject();
  if(reqDto!=null){
omsEvaluationSubject.setEvaluationSubjectName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:61437_1_19197
omsEvaluationSubject.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:114621_1_19197
omsEvaluationSubject.setAscriptionSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:61690_1_19197
omsEvaluationSubject.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:61441_1_19197
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      omsEvaluationSubject.setEvaluationSubjectTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:66920_1_19197
omsEvaluationSubject.setBizSceneCode(queryClassMatchResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:114619_1_19197
    }
if(queryConfSchemeDetailComRespDto!=null){
      omsEvaluationSubject.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:66921_1_19197
    }

    /*3-2-02新增评价主题[2117]   */
Assert.isNull(omsEvaluationSubject.getEvaluationSubjectName(),"D3-2新增评价主题-3-2-02新增评价主题-评价主题名称不能为空",false);
Assert.isNull(omsEvaluationSubject.getEvaluationSubjectTypeCode(),"D3-2新增评价主题-3-2-02新增评价主题-评价主题类型编码 不能为空",false);
Assert.isNull(omsEvaluationSubject.getBizSceneCode(),"D3-2新增评价主题-3-2-02新增评价主题-冗余业务场景标识不能为空",false);
Assert.isNull(omsEvaluationSubject.getConfSchemeId(),"D3-2新增评价主题-3-2-02新增评价主题-冗余配置方案ID 不能为空",false);
Assert.isNull(omsEvaluationSubject.getConfSchemeCode(),"D3-2新增评价主题-3-2-02新增评价主题-冗余配置方案标识不能为空",false);
Assert.isNull(omsEvaluationSubject.getAscriptionSpaceId(),"D3-2新增评价主题-3-2-02新增评价主题-归属空间ID不能为空",false);
Assert.isNull(omsEvaluationSubject.getSubjectLifeCycle(),"D3-2新增评价主题-3-2-02新增评价主题-主体生命周期不能为空",false);
      string = mOmsEvaluationSubjectService.addEvaTheme(omsEvaluationSubject)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_1 = string;
           }
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
        //if(D3-2新增评价主题.主体生命周期 等于 当前有效)  40203

      AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null&&queryClassMatchResultToAnswerDetailComRespDto !=null&&string !=null){
          AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto=new AddOpenRecordAuthorizationComReqDto();
  addOpenRecordAuthorizationComReqDto.setApplexType("EVA_THEME");//sourceId:894278_1_40204
if(reqDto!=null){
      addOpenRecordAuthorizationComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:894270_1_40204
addOpenRecordAuthorizationComReqDto.setAuthType(reqDto.getAuthType());//SimpleFieldAssign//sourceId:894272_1_40204
addOpenRecordAuthorizationComReqDto.setAuthorizationNum(reqDto.getRemainingQty());//SimpleFieldAssign//sourceId:894273_1_40204
addOpenRecordAuthorizationComReqDto.setAuthUnit(reqDto.getAuthUnit());//SimpleFieldAssign//sourceId:894274_1_40204
addOpenRecordAuthorizationComReqDto.setStartTime(reqDto.getStartTime());//SimpleFieldAssign//sourceId:894275_1_40204
addOpenRecordAuthorizationComReqDto.setEndTime(reqDto.getEndTime());//SimpleFieldAssign//sourceId:894276_1_40204
addOpenRecordAuthorizationComReqDto.setIsMainConfScheme(reqDto.getIsMainConfScheme());//SimpleFieldAssign//sourceId:894277_1_40204
addOpenRecordAuthorizationComReqDto.setApplexName(reqDto.getEvaluationSubjectName());//SimpleFieldAssign//sourceId:915056_1_40204
addOpenRecordAuthorizationComReqDto.setTenantSpaceId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:894280_1_40204
addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:894281_1_40204
    }
if(queryConfSchemeDetailComRespDto!=null){
      addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:894271_1_40204
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(queryClassMatchResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:932181_1_40204
    }
if(string!=null){
      addOpenRecordAuthorizationComReqDto.setApplexId(string);//SimpleFieldAssign//sourceId:894279_1_40204
      }

    /*D2新增开通记录并授权(公共)[3102]   */
    Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-配置方案ID 不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-配置方案标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-是否主配置方案不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-开通对象类型编码不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-开通对象ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-租户空间ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(),"D3-2新增评价主题-D2新增开通记录并授权(公共)-主体生命周期不能为空",false);
      addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      addOpenRecordAuthorizationComRespDto_1 = addOpenRecordAuthorizationComRespDto;
    }
      }
//virtualUsage 3-11-04新增评价主题当前步骤  19942
      String string_2 = null;
    if(string !=null){
          OmsBasicInstanceAssistBehaviorCurrentStep omsBasicInstanceAssistBehaviorCurrentStep=new OmsBasicInstanceAssistBehaviorCurrentStep();
  omsBasicInstanceAssistBehaviorCurrentStep.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:388578_1_19942
omsBasicInstanceAssistBehaviorCurrentStep.setStepNameCode("PLAN_DATA");//CUSTOM_CONVENTION//sourceId:388577_1_19942
omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:865993_1_19942
if(string!=null){
      omsBasicInstanceAssistBehaviorCurrentStep.setEntityId(string);//SimpleFieldAssign//sourceId:388579_1_19942
    }
if(reqDto!=null){
      omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentId(reqDto.getAscriptionSpaceId());//SimpleFieldAssign//sourceId:865994_1_19942
    }

    /*3-11-04新增评价主题当前步骤[2427]   */
    Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getEntityId(),"D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤内容实例ID不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepObj(),"D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤使用对象表不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepNameCode(),"D3-2新增评价主题-3-11-04新增评价主题当前步骤-步骤编码不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentTypeCode(),"D3-2新增评价主题-3-11-04新增评价主题当前步骤-主题内容类型编码不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentId(),"D3-2新增评价主题-3-11-04新增评价主题当前步骤-主题内容ID不能为空",false);
      string_2 = mOmsBasicInstanceAssistBehaviorCurrentStepService.addBizAppServiceContCurrentBstep(omsBasicInstanceAssistBehaviorCurrentStep)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_3 = string_2;
           }
AddEvaThemeRespDto retData = new AddEvaThemeRespDto();
  if(string_1!=null){
      retData.setEvaluationSubjectId(string_1);//SimpleFieldAssign//sourceId:61449_1
    }
if(addOpenRecordAuthorizationComRespDto_1!=null){
      retData.setSchOpenRecordId(addOpenRecordAuthorizationComRespDto_1.getSchOpenRecordId());//SimpleFieldAssign//sourceId:895242_1
retData.setApplexRelId(addOpenRecordAuthorizationComRespDto_1.getApplexRelId());//SimpleFieldAssign//sourceId:895239_1
    }
if(string_3!=null){
      retData.setBehaviorCurrentStepId(string_3);//SimpleFieldAssign//sourceId:895241_1
    }


  
  
return retData;
  }
/**
   * D3-2删除评价主题[3162]
   * gen by moon at 9/20/2022, 6:33:17 PM
   */
  @Trace(operationName = "D3-2删除评价主题")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteEvaThemeRespDto deleteEvaTheme(DeleteEvaThemeReqDto reqDto){
    
      
      OmsEvaluationSubject omsEvaluationSubject_1 =null;
//步骤0: 3-2-01查评价主题详情 - queryEvaThemeDetail
     OmsEvaluationSubject omsEvaluationSubject = null;
    QueryEvaThemeDetailReq queryEvaThemeDetailReq=new QueryEvaThemeDetailReq();
  queryEvaThemeDetailReq.setSubjectLifeCycle("EDITING");//sourceId:244991_1
if(reqDto!=null){
      queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//sourceId:244997_1
    }

    /*3-2-01查评价主题详情[2310]   */
    Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(),"D3-2删除评价主题-3-2-01查评价主题详情-评价主题ID不能为空",false);
Assert.isNull(queryEvaThemeDetailReq.getSubjectLifeCycle(),"D3-2删除评价主题-3-2-01查评价主题详情-主体生命周期不能为空",false);
      omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq);
      Assert.isTrue(omsEvaluationSubject== null||  omsEvaluationSubject.getEvaluationSubjectId() ==null,"返回值不能为空",false);

      omsEvaluationSubject_1 = omsEvaluationSubject;

//步骤1: 3-2-01删除评价主题 - deleteEvaTheme
     boolean bOOLEAN ;
    String string=new String();
  if(reqDto!=null){
      string=reqDto.getEvaluationSubjectId();;//sourceId:114748_1
    }
  
    /*3-2-01删除评价主题[3163]   */
    Assert.isNull(string,"D3-2删除评价主题-3-2-01删除评价主题-评价主题ID不能为空",false);
      bOOLEAN = mOmsEvaluationSubjectService.deleteEvaTheme(string);

      
      

//步骤2: D3-12删除内容当前行为步骤(公共) - deleteContCurrentBstepCom
     DeleteContCurrentBstepComRespDto deleteContCurrentBstepComRespDto = null;
    DeleteContCurrentBstepComReqDto deleteContCurrentBstepComReqDto=new DeleteContCurrentBstepComReqDto();
  deleteContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:336178_1
if(reqDto!=null){
      deleteContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//sourceId:336177_1
    }

    /*D3-12删除内容当前行为步骤(公共)[4623]   */
    Assert.isNull(deleteContCurrentBstepComReqDto.getEntityId(),"D3-2删除评价主题-D3-12删除内容当前行为步骤(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(deleteContCurrentBstepComReqDto.getStepObj(),"D3-2删除评价主题-D3-12删除内容当前行为步骤(公共)-步骤使用对象表不能为空",false);
      deleteContCurrentBstepComRespDto = offStateService.deleteContCurrentBstepCom(deleteContCurrentBstepComReqDto);




DeleteEvaThemeRespDto retData = new DeleteEvaThemeRespDto();
  if(omsEvaluationSubject_1!=null){
      retData.setConfSchemeCode(omsEvaluationSubject_1.getConfSchemeCode());//sourceId:332306_1
retData.setAscriptionSpaceId(omsEvaluationSubject_1.getAscriptionSpaceId());//sourceId:332304_1
    }
  

  
  
return retData;
  }
/**
   * D3-2查评价模板详情[3062]
   * gen by moon at 5/9/2023, 5:37:35 AM
   */
  @Trace(operationName = "D3-2查评价模板详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTempDetailRespDto queryEvaTempDetail(QueryEvaTempDetailReqDto reqDto){
    
      
      OmsEvaluationTemplate omsEvaluationTemplate_1 =null;
OmsTarget omsTarget_1 =null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
     OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:102129_1
queryEvaTempDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:102135_1
queryEvaTempDetailReq.setArchivngType(reqDto.getArchivngType());//SimpleFieldAssign//sourceId:160599_1
    }
  
    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-2查评价模板详情-3-2-02查评价模板详情-评价模板ID不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationTemplate== null||  omsEvaluationTemplate.getEvaluationTemplateId() ==null,"找不到数据，系统异常",false);
      
      omsEvaluationTemplate_1 = omsEvaluationTemplate;
    
//步骤1: 3-3-01查目标详情 - queryTargetDetail
     OmsTarget omsTarget = null;
    if(omsEvaluationTemplate !=null){
          QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
if(omsEvaluationTemplate!=null){
      queryTargetDetailReq.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:216230_1
    }
if(reqDto!=null){
      queryTargetDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:216224_1
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3-2查评价模板详情-3-3-01查目标详情-目标ID不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTarget== null||  omsTarget.getTargetId() ==null,"找不到数据，系统异常",false);
      
      omsTarget_1 = omsTarget;
           }
    
QueryEvaTempDetailRespDto retData = new QueryEvaTempDetailRespDto();
  if(omsEvaluationTemplate_1!=null){
      retData.setEvaluationTemplateId(omsEvaluationTemplate_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:102162_1
retData.setEvaluationTemplateCode(omsEvaluationTemplate_1.getEvaluationTemplateCode());//SimpleFieldAssign//sourceId:102163_1
retData.setEvaluationTempNumber(omsEvaluationTemplate_1.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:114939_1
retData.setEvaluationTempName(omsEvaluationTemplate_1.getEvaluationTempName());//SimpleFieldAssign//sourceId:102165_1
retData.setEvaluationTempShortName(omsEvaluationTemplate_1.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:102164_1
retData.setDeptId(omsEvaluationTemplate_1.getDeptId());//SimpleFieldAssign//sourceId:102168_1
retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:102166_1
retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:102167_1
retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:102170_1
retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:102171_1
retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:907878_1
retData.setConfSchemeCode(omsEvaluationTemplate_1.getConfSchemeCode());//SimpleFieldAssign//sourceId:102169_1
retData.setEvaluationTemplateTypeCode(omsEvaluationTemplate_1.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:102172_1
retData.setTargetPlanTempSubtype(omsEvaluationTemplate_1.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:102173_1
retData.setIsOkrPlanScene(omsEvaluationTemplate_1.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:102174_1
retData.setEvaluationSubjectTypeCode(omsEvaluationTemplate_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:102175_1
retData.setBizSceneCode(omsEvaluationTemplate_1.getBizSceneCode());//SimpleFieldAssign//sourceId:102176_1
retData.setPlanningType(omsEvaluationTemplate_1.getPlanningType());//SimpleFieldAssign//sourceId:102177_1
retData.setBatchCode(omsEvaluationTemplate_1.getBatchCode());//SimpleFieldAssign//sourceId:102178_1
retData.setCreateTime(omsEvaluationTemplate_1.getCreateTime());//SimpleFieldAssign//sourceId:114940_1
    }
if(omsTarget_1!=null){
      retData.setTargetCode(omsTarget_1.getTargetCode());//SimpleFieldAssign//sourceId:216242_1
retData.setPeriodicModeTypeCode(omsTarget_1.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:216234_1
    }
  

  
  
return retData;
  }
/**
   * D3-2批量增评价角色(公共)[3216]
   * gen by moon at 10/9/2022, 11:44:26 PM
   */
  @Trace(operationName = "D3-2批量增评价角色(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchAddFillRoleComRespDto batchAddFillRoleCom(BatchAddFillRoleComReqDto reqDto){
    
      
      //步骤0: D2-3查配置项匹配答案列表(公共)（跨服务） - queryConfItemMatchAnswerListCom
     QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
    QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto.setConfItemCode("TEMP_AUDIT_EVA_SET");//CUSTOM_CONVENTION//sourceId:361541_1
queryConfItemMatchAnswerListComReqDto.setIsPlatData("TRUE");//sourceId:361544_1
if(reqDto!=null){
      queryConfItemMatchAnswerListComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:361540_1
    }
  
    /*D2-3查询模板配置评价角色结果列表(公共)[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfSchemeCode(),"D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-配置方案标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(),"D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(),"D3-2批量增评价角色(公共)-D2-3查询模板配置评价角色结果列表(公共)-是否平台数据不能为空",false);
      queryConfItemMatchAnswerListComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData();
      
      
      
    
//步骤1: D1-2查询角色列表ByCodes(公共) - batchQueryRoleListByCodesCom
     BatchQueryRoleListByCodesComRespDto batchQueryRoleListByCodesComRespDto = null;
    if(queryConfItemMatchAnswerListComRespDto !=null){
          BatchQueryRoleListByCodesComReqDto batchQueryRoleListByCodesComReqDto=new BatchQueryRoleListByCodesComReqDto();
  batchQueryRoleListByCodesComReqDto.setRoleType("BUSINESS_ROLE");//sourceId:315167_1
if(queryConfItemMatchAnswerListComRespDto!=null){
      batchQueryRoleListByCodesComReqDto.setRoleCodeList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item->item.getEndValue())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:121910_1
    }
  
    /*D1-2查询角色列表ByCodes(公共)[3223]   */
    Assert.isNull(batchQueryRoleListByCodesComReqDto.getRoleType(),"D3-2批量增评价角色(公共)-D1-2查询角色列表ByCodes(公共)-角色类型不能为空",false);
      batchQueryRoleListByCodesComRespDto = fwBaseRoleClient.batchQueryRoleListByCodesCom(batchQueryRoleListByCodesComReqDto).getData();
      Assert.isTrue(batchQueryRoleListByCodesComRespDto== null||  batchQueryRoleListByCodesComRespDto.getRoleList() ==null|| !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList())|| batchQueryRoleListByCodesComRespDto.getRoleList().size()==0 ,"返回值不能为空",false);
      
      
           }
    
//步骤2: M3生成角色数据集聚合(特殊方法） - generateCollectionsAggregation
     //ModelCode: collectionsMergeData
        GenerateCollectionsAggregationRespDto collectionsMergeDataRes = null;
    if(queryConfItemMatchAnswerListComRespDto !=null){
          GenerateCollectionsAggregationReqDto collectionsMergeDataReq=new GenerateCollectionsAggregationReqDto();
  if(queryConfItemMatchAnswerListComRespDto!= null&&  queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() !=null&& !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())){
      collectionsMergeDataReq.setConfSchemeItemResultList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> {
        ConfSchemeItemResultDto elm =BeanUtil.toBean(item, ConfSchemeItemResultDto.class);
        //elm.setEndValue();//UNION_ID  TODO ruizhe dong
        
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:327681_1
    }
if(batchQueryRoleListByCodesComRespDto!= null&&  batchQueryRoleListByCodesComRespDto.getRoleList() !=null&& !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList())){
      collectionsMergeDataReq.setRoleList(batchQueryRoleListByCodesComRespDto.getRoleList().stream().map(item -> {
        FrameworkSceneRoleDto elm =BeanUtil.toBean(item, FrameworkSceneRoleDto.class);
        //elm.setRoleCode();//UNION_ID  TODO ruizhe dong
        
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:327682_1
    }
  
    /*M3生成角色数据集聚合(特殊方法）[4558]  入参多个数据集，取并集 */
    
      collectionsMergeDataRes = nbEvaTheme.generateCollectionsAggregation(collectionsMergeDataReq);
      
      
      
           }
    
//步骤3: 3-2-06批量增评价填报角色 - batchAddEvaFillRole
     boolean bOOLEAN ;
    List<OmsEvaluationFillRole> listOmsEvaluationFillRole=new ArrayList<>();
  if(collectionsMergeDataRes!= null&&  collectionsMergeDataRes.getRoleList() !=null&& !CollectionUtil.isEmpty(collectionsMergeDataRes.getRoleList())){
      listOmsEvaluationFillRole = //objList-to-objLists
        collectionsMergeDataRes.getRoleList().stream().map(item -> {
      OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
      elm.setRoleTypeCode("APPLICANT");//sourceId:63164_2
elm.setIsSystemType("TRUE");//sourceId:63167_2
if(item!=null){
      elm.setRoleId(item.getRoleId());//SimpleFieldAssign//sourceId:63172_2
elm.setRoleCode(item.getRoleCode());//SimpleFieldAssign//sourceId:63163_2
elm.setRoleName(item.getRoleName());//SimpleFieldAssign//sourceId:63173_2
elm.setOrderNumber(item.getNumber()!=null?Long.valueOf(item.getNumber()):null);//SimpleFieldAssign//sourceId:63168_2
    }
if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:63165_2
elm.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:63169_2
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:121697_1
    }
  
    /*3-2-06批量增评价填报角色[3217]   */
    
      bOOLEAN = mOmsEvaluationFillRoleService.batchAddEvaFillRole(listOmsEvaluationFillRole);
      
      
      
    
BatchAddFillRoleComRespDto retData = new BatchAddFillRoleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2新增评价模板[3100]
   * gen by moon at 7/1/2024, 6:32:23 PM
   */
  @Trace(operationName = "D3-2新增评价模板")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddEvaTempRespDto addEvaTemp(AddEvaTempReqDto reqDto){
    
      
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
      String string_1 =null;
String string_3 =null;
OmsBizAppBatch omsBizAppBatch_2 =null;
String string_5 =null;
//步骤0: M3-获取接收字段（特殊方法） - obtainReceiveField
     //ModelCode: receptionService
        ObtainReceiveFieldRespDto receptionServiceRes = null;
    ObtainReceiveFieldReqDto receptionServiceReq=new ObtainReceiveFieldReqDto();


    /*M3-接收入参字段[2451]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaTheme.obtainReceiveField(receptionServiceReq);




//步骤1: D3-3判断新增的评价模板(公共) - judgeAddEvaTempCom
     JudgeAddEvaTempComRespDto judgeAddEvaTempComRespDto = null;
    JudgeAddEvaTempComReqDto judgeAddEvaTempComReqDto=new JudgeAddEvaTempComReqDto();
  if(reqDto!=null){
      judgeAddEvaTempComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:872605_1
    }
  
    /*D3-3判断新增的评价模板(公共)[4760]   */
    Assert.isNull(judgeAddEvaTempComReqDto.getEvaluationSubjectId(),"D3-2新增评价模板-D3-3判断新增的评价模板(公共)-评价主题ID不能为空",false);
      judgeAddEvaTempComRespDto = judgeAddEvaTempCom(judgeAddEvaTempComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
//步骤2: D2-3查询配置方案详情(公共) - queryConfSchemeDetailCom
     QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
    QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto=new QueryConfSchemeDetailComReqDto();
  if(reqDto!=null){
      queryConfSchemeDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:335460_1
    }
  
    /*D2-3查询配置方案详情(公共)[1981]   */
    Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeCode(),"D3-2新增评价模板-D2-3查询配置方案详情(公共)-配置方案标识不能为空",false);
      queryConfSchemeDetailComRespDto = fwCompConfSchemeClient.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
//步骤3: D2-3查询方案匹配单一结果转答案(公共)（跨服务） - querySchemeMatchSingleResultToAnswerDetailCom
     QuerySchemeMatchSingleResultToAnswerDetailComRespDto querySchemeMatchSingleResultToAnswerDetailComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null){
          QuerySchemeMatchSingleResultToAnswerDetailComReqDto querySchemeMatchSingleResultToAnswerDetailComReqDto=new QuerySchemeMatchSingleResultToAnswerDetailComReqDto();
  querySchemeMatchSingleResultToAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:308586_1
if(reqDto!=null){
      querySchemeMatchSingleResultToAnswerDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:108675_1
    }
if(queryConfSchemeDetailComRespDto!=null){
      querySchemeMatchSingleResultToAnswerDetailComReqDto.setIsInitialScheme(queryConfSchemeDetailComRespDto.getIsInitialScheme());//SimpleFieldAssign//sourceId:108678_1
    }
  
    /*D2-3查询模板配置答案（跨服务）[3101]   */
    Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getConfSchemeCode(),"D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-配置方案标识不能为空",false);
Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getIsInitialScheme(),"D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-是否初始方案答案不能为空",false);
Assert.isNull(querySchemeMatchSingleResultToAnswerDetailComReqDto.getIsPlatData(),"D3-2新增评价模板-D2-3查询模板配置答案（跨服务）-是否标准答案不能为空",false);
      querySchemeMatchSingleResultToAnswerDetailComRespDto = fwCompConfSchemeClient.querySchemeMatchSingleResultToAnswerDetailCom(querySchemeMatchSingleResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(querySchemeMatchSingleResultToAnswerDetailComRespDto== null||  querySchemeMatchSingleResultToAnswerDetailComRespDto.getConfSchemeId() ==null,"找不到数据，系统异常",false);
      
      
           }
    
//步骤4: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_CUSTOM_REPORT");//CUSTOM_CONVENTION//sourceId:939122_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:939131_1
if(queryConfSchemeDetailComRespDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:939133_1
    }

    /*D2-3查是否开启自定义汇报答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(),"D3-2新增评价模板-D2-3查是否开启自定义汇报答案-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-2新增评价模板-D2-3查是否开启自定义汇报答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-2新增评价模板-D2-3查是否开启自定义汇报答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
           }

//步骤5: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
     QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("FINANCE_GROUP");//CUSTOM_CONVENTION//sourceId:1531598_1
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1531599_1
queryClassMatchResultToAnswerDetailComReqDto.setIsSingleResult("TRUE");//sourceId:1531600_1
if(reqDto!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1531597_1
    }

    /*D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-开通对象ID不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-是否标准答案不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsSingleResult(),"D3-2新增评价模板-D2查评价主题预算分组单选配置答案(是否开启预算、是否开启预算汇报）-是否单一答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤6: 3-2-02新增评价模板 - addEvaTemp
     String string = null;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null){
          OmsEvaluationTemplate omsEvaluationTemplate=new OmsEvaluationTemplate();
  if(reqDto!=null){
      omsEvaluationTemplate.setEvaluationTempNumber(reqDto.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:106543_1
omsEvaluationTemplate.setEvaluationTempName(reqDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:106544_1
omsEvaluationTemplate.setEvaluationTempShortName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:106545_1
omsEvaluationTemplate.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:106547_1
omsEvaluationTemplate.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:106548_1
omsEvaluationTemplate.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:106556_1
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
      omsEvaluationTemplate.setIsOpenBudget(queryClassMatchResultToAnswerDetailComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:172535_1
omsEvaluationTemplate.setIsOpenBudgetReport(queryClassMatchResultToAnswerDetailComRespDto.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:172536_1
    }
if(querySchemeMatchSingleResultToAnswerDetailComRespDto!=null){
omsEvaluationTemplate.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:106553_1
omsEvaluationTemplate.setEvaluationTemplateTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:106549_1
omsEvaluationTemplate.setTargetPlanTempSubtype(querySchemeMatchSingleResultToAnswerDetailComRespDto.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:106555_1
omsEvaluationTemplate.setIsOkrPlanScene(querySchemeMatchSingleResultToAnswerDetailComRespDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:106550_1
omsEvaluationTemplate.setEvaluationSubjectTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:106551_1
omsEvaluationTemplate.setBizSceneCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:106552_1
    }
if(queryConfSchemeDetailComRespDto!=null){
      omsEvaluationTemplate.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:907076_1
    }

    /*3-2-02新增评价模板[2344]   */
    Assert.isNull(omsEvaluationTemplate.getEvaluationTempNumber(),"D3-2新增评价模板-3-2-02新增评价模板-评价模板编号不能为空",false);
Assert.isNull(omsEvaluationTemplate.getEvaluationTempName(),"D3-2新增评价模板-3-2-02新增评价模板-评价模板名称不能为空",false);
Assert.isNull(omsEvaluationTemplate.getEvaluationTempShortName(),"D3-2新增评价模板-3-2-02新增评价模板-评价模板简称不能为空",false);
Assert.isNull(omsEvaluationTemplate.getEvaluationSubjectId(),"D3-2新增评价模板-3-2-02新增评价模板-归属评价主题ID不能为空",false);
Assert.isNull(omsEvaluationTemplate.getIsOpenBudget(),"D3-2新增评价模板-3-2-02新增评价模板-是否开启预算不能为空",false);
Assert.isNull(omsEvaluationTemplate.getIsOpenBudgetReport(),"D3-2新增评价模板-3-2-02新增评价模板-是否开启预算汇报不能为空",false);
Assert.isNull(omsEvaluationTemplate.getPlanningType(),"D3-2新增评价模板-3-2-02新增评价模板-规划类型不能为空",false);
Assert.isNull(omsEvaluationTemplate.getEvaluationTemplateTypeCode(),"D3-2新增评价模板-3-2-02新增评价模板-冗余评价模板类型配置项不能为空",false);
Assert.isNull(omsEvaluationTemplate.getTargetPlanTempSubtype(),"D3-2新增评价模板-3-2-02新增评价模板-冗余目标规划模板子类型不能为空",false);
Assert.isNull(omsEvaluationTemplate.getIsOkrPlanScene(),"D3-2新增评价模板-3-2-02新增评价模板-冗余开启OKR场景配置项不能为空",false);
Assert.isNull(omsEvaluationTemplate.getEvaluationSubjectTypeCode(),"D3-2新增评价模板-3-2-02新增评价模板-冗余评价主题类型配置项不能为空",false);
Assert.isNull(omsEvaluationTemplate.getBizSceneCode(),"D3-2新增评价模板-3-2-02新增评价模板-冗余业务场景标识配置项不能为空",false);
Assert.isNull(omsEvaluationTemplate.getConfSchemeId(),"D3-2新增评价模板-3-2-02新增评价模板-冗余配置方案ID 不能为空",false);
Assert.isNull(omsEvaluationTemplate.getConfSchemeCode(),"D3-2新增评价模板-3-2-02新增评价模板-冗余配置方案标识不能为空",false);
      string = mOmsEvaluationTemplateService.addEvaTemp(omsEvaluationTemplate)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_1 = string;
           }
    
//步骤7: D3执行评价模板批次相关设置初始化(公共) - implementEvaTempBatchSetInitializeCom
     ImplementEvaTempBatchSetInitializeComRespDto implementEvaTempBatchSetInitializeComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null){
          ImplementEvaTempBatchSetInitializeComReqDto implementEvaTempBatchSetInitializeComReqDto=new ImplementEvaTempBatchSetInitializeComReqDto();
  if(queryConfSchemeDetailComRespDto!=null){
      implementEvaTempBatchSetInitializeComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:834290_1
    }
    if(string !=null){
      implementEvaTempBatchSetInitializeComReqDto.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:834291_1
    }
  
    /*D3执行评价模板批次相关设置初始化(公共)[6299]   */
    Assert.isNull(implementEvaTempBatchSetInitializeComReqDto.getConfSchemeId(),"D3-2新增评价模板-D3执行评价模板批次相关设置初始化(公共)-配置方案ID 不能为空",false);
Assert.isNull(implementEvaTempBatchSetInitializeComReqDto.getEvaluationTemplateId(),"D3-2新增评价模板-D3执行评价模板批次相关设置初始化(公共)-冗余评价模板ID不能为空",false);
      implementEvaTempBatchSetInitializeComRespDto = batchService.implementEvaTempBatchSetInitializeCom(implementEvaTempBatchSetInitializeComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤8: M3-生成语义内容 - generateSemanticContent
     //ModelCode: generateSemanticInstance
        GenerateEvaTempBatchNameRespDto generateSemanticInstanceRes = null;
    GenerateEvaTempBatchNameReqDto generateSemanticInstanceReq=new GenerateEvaTempBatchNameReqDto();
  generateSemanticInstanceReq.setSystemDateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:108819_1
generateSemanticInstanceReq.setRandomNumberDigits(Long.valueOf(6));//CUSTOM_CONVENTION//sourceId:108820_1
if(reqDto!=null){
      generateSemanticInstanceReq.setTargetContentName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:336642_1
    }
  
    /*M生成评价模板批次名称[2391]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq.getSystemDateTime(),"D3-2新增评价模板-M生成评价模板批次名称-系统当前时间不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getRandomNumberDigits(),"D3-2新增评价模板-M生成评价模板批次名称-随机数位数不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getTargetContentName(),"D3-2新增评价模板-M生成评价模板批次名称-目标内容名称不能为空",false);
      generateSemanticInstanceRes = nbEvaTheme.generateEvaTempBatchName(generateSemanticInstanceReq);
      
      
      
    
//步骤9: 3-13-01新增业务应用批次 - addBizAppBatch
     String string_2 = null;
    if(string !=null){
          OmsBizAppBatch omsBizAppBatch=new OmsBizAppBatch();
  omsBizAppBatch.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:106560_1
omsBizAppBatch.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:106564_1
omsBizAppBatch.setIsFirst("TRUE");//sourceId:106562_1
omsBizAppBatch.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:865987_1
if(generateSemanticInstanceRes!=null){
      omsBizAppBatch.setBatchName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:106559_1
    }
if(string!=null){
      omsBizAppBatch.setAscriptionObjectId(string);//SimpleFieldAssign//sourceId:106561_1
omsBizAppBatch.setThemeContentId(string);//SimpleFieldAssign//sourceId:865988_1
    }
  
    /*3-13-01新增业务应用批次[2348]   */
    Assert.isNull(omsBizAppBatch.getBatchName(),"D3-2新增评价模板-3-13-01新增业务应用批次-批次名称不能为空",false);
Assert.isNull(omsBizAppBatch.getAscriptionObjectId(),"D3-2新增评价模板-3-13-01新增业务应用批次-归属对象ID不能为空",false);
Assert.isNull(omsBizAppBatch.getPurposeTypeCode(),"D3-2新增评价模板-3-13-01新增业务应用批次-用途类型编码不能为空",false);
Assert.isNull(omsBizAppBatch.getBatchEndTime(),"D3-2新增评价模板-3-13-01新增业务应用批次-批次结束时间不能为空",false);
Assert.isNull(omsBizAppBatch.getIsFirst(),"D3-2新增评价模板-3-13-01新增业务应用批次-是否首次批次不能为空",false);
Assert.isNull(omsBizAppBatch.getThemeContentTypeCode(),"D3-2新增评价模板-3-13-01新增业务应用批次-主题内容类型编码不能为空",false);
Assert.isNull(omsBizAppBatch.getThemeContentId(),"D3-2新增评价模板-3-13-01新增业务应用批次-主题内容ID不能为空",false);
      string_2 = mOmsBizAppBatchService.addBizAppBatch(omsBizAppBatch)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_3 = string_2;
           }
    
//步骤10: 3-13-01查业务应用批次详情 - queryBizAppBatchDetail
     OmsBizAppBatch omsBizAppBatch_1 = null;
    if(string_2 !=null){
          QueryBizAppBatchDetailReq queryBizAppBatchDetailReq=new QueryBizAppBatchDetailReq();
  queryBizAppBatchDetailReq.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:322710_1
queryBizAppBatchDetailReq.setIsNewbatch("TRUE");//sourceId:322714_1
if(string_2!=null){
      queryBizAppBatchDetailReq.setBatchId(string_2);//SimpleFieldAssign//sourceId:322717_1
    }
if(string!=null){
      queryBizAppBatchDetailReq.setAscriptionObjectId(string);//SimpleFieldAssign//sourceId:322711_1
    }
  
    /*3-13-01查业务应用批次详情[2668]   */
    Assert.isNull(queryBizAppBatchDetailReq.getBatchId(),"D3-2新增评价模板-3-13-01查业务应用批次详情-批次ID不能为空",false);
Assert.isNull(queryBizAppBatchDetailReq.getPurposeTypeCode(),"D3-2新增评价模板-3-13-01查业务应用批次详情-用途类型编码不能为空",false);
Assert.isNull(queryBizAppBatchDetailReq.getAscriptionObjectId(),"D3-2新增评价模板-3-13-01查业务应用批次详情-归属对象ID不能为空",false);
Assert.isNull(queryBizAppBatchDetailReq.getIsNewbatch(),"D3-2新增评价模板-3-13-01查业务应用批次详情-是否最新批次不能为空",false);
      omsBizAppBatch_1 = mOmsBizAppBatchService.queryBizAppBatchDetail(queryBizAppBatchDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      omsBizAppBatch_2 = omsBizAppBatch_1;
           }
    
//步骤11: 3-3-01新增目标 - addTarget
     String string_4 = null;
    if(querySchemeMatchSingleResultToAnswerDetailComRespDto !=null){
          OmsTarget omsTarget=new OmsTarget();
  omsTarget.setTargetCode("1001");//CUSTOM_CONVENTION//sourceId:106599_1
omsTarget.setIsOpenCustomReport("FALSE");//sourceId:974702_1
omsTarget.setDataInitStatus("FALSE");//sourceId:335454_1
omsTarget.setTargetPgsStatus("NOT_AT_THE");//sourceId:315080_1
if(querySchemeMatchSingleResultToAnswerDetailComRespDto!=null){
      omsTarget.setPeriodicModeTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:106600_1
omsTarget.setBizSceneCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getBizSceneCode());//SimpleFieldAssign//sourceId:335455_1
omsTarget.setEvaluationSubjectTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:335456_1
omsTarget.setEvaluationTemplateTypeCode(querySchemeMatchSingleResultToAnswerDetailComRespDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:335457_1
omsTarget.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:335458_1
    }
if(string!=null){
      omsTarget.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:106601_1
    }
if(reqDto!=null){
      omsTarget.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:106602_1
    }
if(omsBizAppBatch_1!=null){
      omsTarget.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:106603_1
    }
  
    /*3-3-01新增目标[2345]   */
    Assert.isNull(omsTarget.getTargetCode(),"D3-2新增评价模板-3-3-01新增目标-目标标识不能为空",false);
Assert.isNull(omsTarget.getPeriodicModeTypeCode(),"D3-2新增评价模板-3-3-01新增目标-周期模式类型编码不能为空",false);
Assert.isNull(omsTarget.getEvaluationTemplateId(),"D3-2新增评价模板-3-3-01新增目标-归属评价模板ID不能为空",false);
Assert.isNull(omsTarget.getEvaluationSubjectId(),"D3-2新增评价模板-3-3-01新增目标-冗余评价主题ID不能为空",false);
Assert.isNull(omsTarget.getIsOpenCustomReport(),"D3-2新增评价模板-3-3-01新增目标-是否开启自定义汇报不能为空",false);
Assert.isNull(omsTarget.getDataInitStatus(),"D3-2新增评价模板-3-3-01新增目标-数据初始化完成状态不能为空",false);
Assert.isNull(omsTarget.getBizSceneCode(),"D3-2新增评价模板-3-3-01新增目标-冗余业务场景标识配置项不能为空",false);
Assert.isNull(omsTarget.getEvaluationSubjectTypeCode(),"D3-2新增评价模板-3-3-01新增目标-冗余评价主题类型配置项不能为空",false);
Assert.isNull(omsTarget.getEvaluationTemplateTypeCode(),"D3-2新增评价模板-3-3-01新增目标-冗余评价模板类型配置项不能为空",false);
Assert.isNull(omsTarget.getPlanningType(),"D3-2新增评价模板-3-3-01新增目标-冗余规划类型不能为空",false);
Assert.isNull(omsTarget.getTargetPgsStatus(),"D3-2新增评价模板-3-3-01新增目标-目标进展状态不能为空",false);
Assert.isNull(omsTarget.getBatchCode(),"D3-2新增评价模板-3-3-01新增目标-批次标识不能为空",false);
      string_4 = mOmsTargetService.addTarget(omsTarget)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_5 = string_4;
           }
    
//步骤12: 3-2-02修改评价模板 - updateEvaTemp
     boolean bOOLEAN ;
    if(string !=null){
          OmsEvaluationTemplate omsEvaluationTemplate_1=new OmsEvaluationTemplate();
  if(string!=null){
      omsEvaluationTemplate_1.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:106605_1
    }
if(string_4!=null){
      omsEvaluationTemplate_1.setTargetId(string_4);//SimpleFieldAssign//sourceId:106607_1
    }
if(omsBizAppBatch_1!=null){
      omsEvaluationTemplate_1.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:106606_1
    }
  
    /*3-2-02修改评价模板[2393]   */
    Assert.isNull(omsEvaluationTemplate_1.getEvaluationTemplateId(),"D3-2新增评价模板-3-2-02修改评价模板-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationTemplate_1.getTargetId(),"D3-2新增评价模板-3-2-02修改评价模板-对应的目标ID不能为空",false);
Assert.isNull(omsEvaluationTemplate_1.getBatchCode(),"D3-2新增评价模板-3-2-02修改评价模板-批次标识不能为空",false);
      bOOLEAN = mOmsEvaluationTemplateService.updateEvaTemp(omsEvaluationTemplate_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤13: D3-5新增规划资料(公共) - addPlanDataCom
     AddPlanDataComRespDto addPlanDataComRespDto = null;
    if(querySchemeMatchSingleResultToAnswerDetailComRespDto !=null){
          AddPlanDataComReqDto addPlanDataComReqDto=new AddPlanDataComReqDto();
  addPlanDataComReqDto.setIsMainplan("TRUE");//sourceId:1914397_1
addPlanDataComReqDto.setPlanSchemeClass("MASTER_PLAN");//sourceId:1914400_1
if(reqDto!=null){
      addPlanDataComReqDto.setPlanningNumber(reqDto.getEvaluationTempNumber());//SimpleFieldAssign//sourceId:1914394_1
addPlanDataComReqDto.setPlanningName(reqDto.getEvaluationTempName());//SimpleFieldAssign//sourceId:1914395_1
addPlanDataComReqDto.setPlanningShortName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1914396_1
addPlanDataComReqDto.setHypertextContent(reqDto.getHypertextContent());//SimpleFieldAssign//sourceId:222453_1
addPlanDataComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1914405_1
    }
if(querySchemeMatchSingleResultToAnswerDetailComRespDto!=null){
      addPlanDataComReqDto.setOkrType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getOkrType());//SimpleFieldAssign//sourceId:1914398_1
addPlanDataComReqDto.setPlanningType(querySchemeMatchSingleResultToAnswerDetailComRespDto.getPlanningType());//SimpleFieldAssign//sourceId:1914399_1
    }
if(string!=null){
      addPlanDataComReqDto.setEvaObjTargetCycleId(string);//SimpleFieldAssign//sourceId:1914407_1
addPlanDataComReqDto.setEvaluationTemplateId(string);//SimpleFieldAssign//sourceId:1914403_1
    }
if(omsBizAppBatch_1!=null){
      addPlanDataComReqDto.setBatchCode(omsBizAppBatch_1.getBatchCode());//SimpleFieldAssign//sourceId:1914404_1
    }
  
    /*D3-5新增规划资料(公共)[3137]   */
    Assert.isNull(addPlanDataComReqDto.getPlanningNumber(),"D3-2新增评价模板-D3-5新增规划资料(公共)-规划编号不能为空",false);
Assert.isNull(addPlanDataComReqDto.getPlanningName(),"D3-2新增评价模板-D3-5新增规划资料(公共)-规划名称不能为空",false);
Assert.isNull(addPlanDataComReqDto.getPlanningShortName(),"D3-2新增评价模板-D3-5新增规划资料(公共)-规划简称不能为空",false);
Assert.isNull(addPlanDataComReqDto.getHypertextContent(),"D3-2新增评价模板-D3-5新增规划资料(公共)-超文本内容不能为空",false);
Assert.isNull(addPlanDataComReqDto.getIsMainplan(),"D3-2新增评价模板-D3-5新增规划资料(公共)-是否总规划不能为空",false);
Assert.isNull(addPlanDataComReqDto.getOkrType(),"D3-2新增评价模板-D3-5新增规划资料(公共)-OKR类型不能为空",false);
Assert.isNull(addPlanDataComReqDto.getPlanningType(),"D3-2新增评价模板-D3-5新增规划资料(公共)-规划类型不能为空",false);
Assert.isNull(addPlanDataComReqDto.getPlanSchemeClass(),"D3-2新增评价模板-D3-5新增规划资料(公共)-规划方案类别不能为空",false);
Assert.isNull(addPlanDataComReqDto.getEvaObjTargetCycleId(),"D3-2新增评价模板-D3-5新增规划资料(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(addPlanDataComReqDto.getEvaluationTemplateId(),"D3-2新增评价模板-D3-5新增规划资料(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addPlanDataComReqDto.getBatchCode(),"D3-2新增评价模板-D3-5新增规划资料(公共)-批次标识不能为空",false);
      addPlanDataComRespDto = planDataService.addPlanDataCom(addPlanDataComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤14: D3新增定时任务调度(公共) - addTimerTaskPlanCom
     AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    if(string_4 !=null){
          AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
  addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:389199_1
addTimerTaskPlanComReqDto.setDispatchActionTypeCode("STAGE_CURRENT_CYCLE_ETC");//sourceId:389200_1
addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:389201_1
addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:389202_1
addTimerTaskPlanComReqDto.setStandbyField1("1001");//CUSTOM_CONVENTION//sourceId:389216_1
addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:389205_1
addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:540769_1
addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:972433_1
addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:389214_1
addTimerTaskPlanComReqDto.setIsRealTimeaSync("FALSE");//sourceId:731006_1
addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:389211_1
addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:389212_1
addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:389213_1
if(reqDto!=null){
      addTimerTaskPlanComReqDto.setTargetContentName(reqDto.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:389198_1
    }
if(string_4!=null){
      addTimerTaskPlanComReqDto.setObjectId(string_4);//SimpleFieldAssign//sourceId:389203_1
    }
if(string!=null){
      addTimerTaskPlanComReqDto.setAddRuleInfoId(string);//SimpleFieldAssign//sourceId:389206_1
addTimerTaskPlanComReqDto.setThemeContentId(string);//SimpleFieldAssign//sourceId:540770_1
    }
  
    /*D3-2新增更新执行周期阶段当前周期等任务[4995]   */
    Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-目标内容名称不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-是否补偿任务不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-任务调度的行为类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-任务调度类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-备用字段1不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-生成规则信息类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-生成辅助规则信息值不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-主题内容类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-主题内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-是否执行完成不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-操作人就职记录ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-创建于空间ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAppId(),"D3-2新增评价模板-D3-2新增更新执行周期阶段当前周期等任务-创建于联盟应用ID不能为空",false);
      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤15: 3-11-04新增业务应用内容当前行为步骤 - addBizAppServiceContCurrentBstep
     String string_6 = null;
    if(string !=null){
          OmsBasicInstanceAssistBehaviorCurrentStep omsBasicInstanceAssistBehaviorCurrentStep=new OmsBasicInstanceAssistBehaviorCurrentStep();
  omsBasicInstanceAssistBehaviorCurrentStep.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:387990_1
omsBasicInstanceAssistBehaviorCurrentStep.setStepNameCode("COMPILE_TARGET_TASK");//CUSTOM_CONVENTION//sourceId:387989_1
omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:867474_1
if(string!=null){
      omsBasicInstanceAssistBehaviorCurrentStep.setEntityId(string);//SimpleFieldAssign//sourceId:387991_1
omsBasicInstanceAssistBehaviorCurrentStep.setThemeContentId(string);//SimpleFieldAssign//sourceId:867475_1
    }
  
    /*3-11-04新增评价模板当前行为步骤[2427]   */
    Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getEntityId(),"D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤内容实例ID不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepObj(),"D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤使用对象表不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getStepNameCode(),"D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-步骤编码不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentTypeCode(),"D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-主题内容类型编码不能为空",false);
Assert.isNull(omsBasicInstanceAssistBehaviorCurrentStep.getThemeContentId(),"D3-2新增评价模板-3-11-04新增评价模板当前行为步骤-主题内容ID不能为空",false);
      string_6 = mOmsBasicInstanceAssistBehaviorCurrentStepService.addBizAppServiceContCurrentBstep(omsBasicInstanceAssistBehaviorCurrentStep)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤16: D3-更新业务服务内容当前步骤(公共) - refreshBizAppServiceContCurrentBstepCom
     RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
    RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto=new RefreshBizAppServiceContCurrentBstepComReqDto();
  refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:334722_1
refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:334720_1
refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:334719_1
if(reqDto!=null){
      refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334718_1
    }
  
    /*D3-更新评价主题当前步骤(第2步)[4593]   */
    Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(),"D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-步骤内容实例ID不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(),"D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-步骤使用对象表不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(),"D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-业务场景标识不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(),"D3-2新增评价模板-D3-更新评价主题当前步骤(第2步)-排序不能为空",false);
      refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
AddEvaTempRespDto retData = new AddEvaTempRespDto();
  if(string_1!=null){
      retData.setEvaluationTemplateId(string_1);//SimpleFieldAssign//sourceId:108822_1
    }
if(string_3!=null){
      retData.setBatchId(string_3);//SimpleFieldAssign//sourceId:322702_1
    }
if(omsBizAppBatch_2!=null){
      retData.setBatchCode(omsBizAppBatch_2.getBatchCode());//SimpleFieldAssign//sourceId:322815_1
    }
if(string_5!=null){
      retData.setTargetId(string_5);//SimpleFieldAssign//sourceId:108824_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setEndValue(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:939291_1
    }


  
  
return retData;
  }
/**
   * D3-2新增评价画像相关[3112]
   * gen by moon at 2/26/2024, 3:29:13 AM
   */
  @Trace(operationName = "D3-2新增评价画像相关")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddEvaPortraitRelatedRespDto addEvaPortraitRelated(AddEvaPortraitRelatedReqDto reqDto){
    
      
      String string_1 =null;
String string_3 =null;
AddEvaFillRoleComRespDto addEvaFillRoleComRespDto_1 =null;
String string_5 =null;
String string_7 =null;
String string_9 =null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
     OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:108655_1
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:108649_1
    }
  
    /*3-2-02查评价模板[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-2-02查评价模板-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-2新增评价画像相关-3-2-02查评价模板-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("EVA_THEME_HOST_TYPE_CODE");//CUSTOM_CONVENTION//sourceId:374285_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:374294_1
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:374287_1
    }
  
    /*D2-3查画像宿主类型标识答案（评价主题）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-2新增评价画像相关-D2-3查画像宿主类型标识答案（评价主题）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
    
//步骤2: 3-2-04新增评价画像 - addEvaPortrait
     String string = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          OmsEvaluationPortrait omsEvaluationPortrait=new OmsEvaluationPortrait();
  omsEvaluationPortrait.setParentChildTemplate("FALSE");//sourceId:374280_1
omsEvaluationPortrait.setIsSystemType("TRUE");//sourceId:374281_1
omsEvaluationPortrait.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:374282_1
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      omsEvaluationPortrait.setHostTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:374278_1
    }
if(reqDto!=null){
      omsEvaluationPortrait.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374279_1
    }
if(omsEvaluationTemplate!=null){
      omsEvaluationPortrait.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637749_1
      omsEvaluationPortrait.setEvaluationObjectInputValue(omsEvaluationTemplate.getSpaceId());//SimpleFieldAssign//sourceId:374299_1
omsEvaluationPortrait.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:374283_1
    }
  
    /*3-2-04新增评价画像[2349]   */
    Assert.isNull(omsEvaluationPortrait.getHostTypeCode(),"D3-2新增评价画像相关-3-2-04新增评价画像-评价画像宿主类型标识不能为空",false);
Assert.isNull(omsEvaluationPortrait.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-2-04新增评价画像-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationPortrait.getEvaluationSubjectId(),"D3-2新增评价画像相关-3-2-04新增评价画像-冗余评价主题ID不能为空",false);
Assert.isNull(omsEvaluationPortrait.getParentChildTemplate(),"D3-2新增评价画像相关-3-2-04新增评价画像-是否支持父子模板不能为空",false);
Assert.isNull(omsEvaluationPortrait.getIsSystemType(),"D3-2新增评价画像相关-3-2-04新增评价画像-是否系统类型不能为空",false);
Assert.isNull(omsEvaluationPortrait.getEvaluationObjectInputValue(),"D3-2新增评价画像相关-3-2-04新增评价画像-查询虚拟宿主的实例条件不能为空",false);
Assert.isNull(omsEvaluationPortrait.getOrderNumber(),"D3-2新增评价画像相关-3-2-04新增评价画像-排序不能为空",false);
Assert.isNull(omsEvaluationPortrait.getBatchCode(),"D3-2新增评价画像相关-3-2-04新增评价画像-批次标识不能为空",false);
      string = mOmsEvaluationPortraitService.addEvaPortrait(omsEvaluationPortrait)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_1 = string;
           }
    
//步骤3: 3-2-05新增评价对象 - addEvaObject
     String string_2 = null;
    if(string !=null){
          OmsEvaluationObject omsEvaluationObject=new OmsEvaluationObject();
  omsEvaluationObject.setTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:107255_1
omsEvaluationObject.setEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:107256_1
omsEvaluationObject.setIsAutoSystem("TRUE");//sourceId:107254_1
omsEvaluationObject.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107257_1
if(string!=null){
      omsEvaluationObject.setEvaluationPortraitId(string);//SimpleFieldAssign//sourceId:374296_1
    }
if(reqDto!=null){
      omsEvaluationObject.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158730_1
    }
if(omsEvaluationTemplate!=null){
      omsEvaluationObject.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637751_1
      omsEvaluationObject.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107258_1
    }
  
    /*3-2-05新增评价对象[2350]   */
    Assert.isNull(omsEvaluationObject.getEvaluationPortraitId(),"D3-2新增评价画像相关-3-2-05新增评价对象-评价画像ID不能为空",false);
Assert.isNull(omsEvaluationObject.getTableTypeCode(),"D3-2新增评价画像相关-3-2-05新增评价对象-内容表类型编码不能为空",false);
Assert.isNull(omsEvaluationObject.getEntityId(),"D3-2新增评价画像相关-3-2-05新增评价对象-内容表主键ID不能为空",false);
Assert.isNull(omsEvaluationObject.getIsAutoSystem(),"D3-2新增评价画像相关-3-2-05新增评价对象-是否系统自动数据不能为空",false);
Assert.isNull(omsEvaluationObject.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-2-05新增评价对象-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationObject.getEvaluationSubjectId(),"D3-2新增评价画像相关-3-2-05新增评价对象-冗余评价主题ID不能为空",false);
Assert.isNull(omsEvaluationObject.getOrderNumber(),"D3-2新增评价画像相关-3-2-05新增评价对象-排序不能为空",false);
Assert.isNull(omsEvaluationObject.getBatchCode(),"D3-2新增评价画像相关-3-2-05新增评价对象-批次标识不能为空",false);
      string_2 = mOmsEvaluationObjectService.addEvaObject(omsEvaluationObject)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_3 = string_2;
           }
    
//步骤4: D3-2新增评价填报角色(公共) - addEvaFillRoleCom
     AddEvaFillRoleComRespDto addEvaFillRoleComRespDto = null;
    if(omsEvaluationTemplate !=null){
          AddEvaFillRoleComReqDto addEvaFillRoleComReqDto=new AddEvaFillRoleComReqDto();
  if(omsEvaluationTemplate!=null){
      addEvaFillRoleComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:952861_1
addEvaFillRoleComReqDto.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637757_1
addEvaFillRoleComReqDto.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:376034_1
    }
if(reqDto!=null){
      addEvaFillRoleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:376033_1
    }
  
    /*D3-2新增评价填报角色(公共)[4830]   */
    Assert.isNull(addEvaFillRoleComReqDto.getConfSchemeId(),"D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-配置方案ID 不能为空",false);
Assert.isNull(addEvaFillRoleComReqDto.getEvaluationTemplateId(),"D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addEvaFillRoleComReqDto.getEvaluationSubjectId(),"D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-冗余评价主题ID不能为空",false);
Assert.isNull(addEvaFillRoleComReqDto.getBatchCode(),"D3-2新增评价画像相关-D3-2新增评价填报角色(公共)-批次标识不能为空",false);
      addEvaFillRoleComRespDto = addEvaFillRoleCom(addEvaFillRoleComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      addEvaFillRoleComRespDto_1 = addEvaFillRoleComRespDto;
           }
    
//步骤5: 3-6-01新增虚拟组织 - addVirtualOrg
     String string_4 = null;
    if(omsEvaluationTemplate !=null){
          OmsVirtualOrg omsVirtualOrg=new OmsVirtualOrg();
  omsVirtualOrg.setTableTypeCode("OMS_TARGET");//sourceId:107279_1
omsVirtualOrg.setEvaluationTemplateType("EVA_TEMP");//sourceId:177124_1
omsVirtualOrg.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559824_1
omsVirtualOrg.setSubjectLifeCycle("EDITING");//sourceId:315168_1
if(omsEvaluationTemplate!=null){
      omsVirtualOrg.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107280_1
omsVirtualOrg.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158728_1
omsVirtualOrg.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107281_1
omsVirtualOrg.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559825_1
    }
  
    /*3-6-03新增规划组[2352]   */
    Assert.isNull(omsVirtualOrg.getEntityId(),"D3-2新增评价画像相关-3-6-03新增规划组-内容表主键ID不能为空",false);
Assert.isNull(omsVirtualOrg.getTableTypeCode(),"D3-2新增评价画像相关-3-6-03新增规划组-内容表类型编码不能为空",false);
Assert.isNull(omsVirtualOrg.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-6-03新增规划组-归属对象ID不能为空",false);
Assert.isNull(omsVirtualOrg.getEvaluationTemplateType(),"D3-2新增评价画像相关-3-6-03新增规划组-归属对象类型不能为空",false);
Assert.isNull(omsVirtualOrg.getBatchCode(),"D3-2新增评价画像相关-3-6-03新增规划组-批次标识不能为空",false);
Assert.isNull(omsVirtualOrg.getCreateBatchCode(),"D3-2新增评价画像相关-3-6-03新增规划组-创建于批次标识不能为空",false);
Assert.isNull(omsVirtualOrg.getUseScene(),"D3-2新增评价画像相关-3-6-03新增规划组-虚拟组织使用场景不能为空",false);
Assert.isNull(omsVirtualOrg.getSubjectLifeCycle(),"D3-2新增评价画像相关-3-6-03新增规划组-主体生命周期不能为空",false);
      string_4 = mOmsVirtualOrgService.addVirtualOrg(omsVirtualOrg)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_5 = string_4;
           }
    
//步骤6: D3分析规划工作组开始时间(公共) - implementWorkGroupStartTimeCom
     ImplementWorkGroupStartTimeComRespDto implementWorkGroupStartTimeComRespDto = null;
    if(omsEvaluationTemplate !=null){
          ImplementWorkGroupStartTimeComReqDto implementWorkGroupStartTimeComReqDto=new ImplementWorkGroupStartTimeComReqDto();
if(reqDto!=null){
      implementWorkGroupStartTimeComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1026853_1
    }
if(omsEvaluationTemplate!=null){
      implementWorkGroupStartTimeComReqDto.setCreateTime(omsEvaluationTemplate.getCreateTime());//SimpleFieldAssign//sourceId:1026860_1
    }

    /*D3分析规划工作组开始时间(公共)[7166]   */
    Assert.isNull(implementWorkGroupStartTimeComReqDto.getCycleStartTime(),"D3-2新增评价画像相关-D3分析规划工作组开始时间(公共)-目标计划开始时间不能为空",false);
Assert.isNull(implementWorkGroupStartTimeComReqDto.getCreateTime(),"D3-2新增评价画像相关-D3分析规划工作组开始时间(公共)-创建时间不能为空",false);
      implementWorkGroupStartTimeComRespDto = virtualOrgService.implementWorkGroupStartTimeCom(implementWorkGroupStartTimeComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤7: 3-6-03新增虚拟成员部门 - addVirtualOrgMemberDept
     String string_6 = null;
    if(string_4 !=null){
          OmsVirtualOrgMemberDept omsVirtualOrgMemberDept=new OmsVirtualOrgMemberDept();
  omsVirtualOrgMemberDept.setDeptType("LEAD_DEPT");//sourceId:107295_1
omsVirtualOrgMemberDept.setVirtualOrgDeptStatus("牵头部门");//CUSTOM_CONVENTION//sourceId:107302_1
omsVirtualOrgMemberDept.setIsDisplay("TRUE");//sourceId:107297_1
omsVirtualOrgMemberDept.setTableTypeCode("OMS_TARGET");//sourceId:107298_1
omsVirtualOrgMemberDept.setEvaluationTemplateType("EVA_TEMP");//sourceId:167494_1
omsVirtualOrgMemberDept.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559826_1
omsVirtualOrgMemberDept.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107303_1
if(string_4!=null){
      omsVirtualOrgMemberDept.setVirtualOrgId(string_4);//SimpleFieldAssign//sourceId:107294_1
    }
if(omsEvaluationTemplate!=null){
      omsVirtualOrgMemberDept.setDeptId(omsEvaluationTemplate.getDeptId());//SimpleFieldAssign//sourceId:107296_1
omsVirtualOrgMemberDept.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107299_1
omsVirtualOrgMemberDept.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107300_1
omsVirtualOrgMemberDept.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559827_1
}
if(implementWorkGroupStartTimeComRespDto!=null){
      omsVirtualOrgMemberDept.setStartTime(implementWorkGroupStartTimeComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:379924_1
    }
if(reqDto!=null){
      omsVirtualOrgMemberDept.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:167492_1
    }
  
    /*3-6-03新增牵头部门[2355]   */
    Assert.isNull(omsVirtualOrgMemberDept.getVirtualOrgId(),"D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织ID 不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getDeptType(),"D3-2新增评价画像相关-3-6-03新增牵头部门-部门类型编码不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getDeptId(),"D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织下部门ID不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getVirtualOrgDeptStatus(),"D3-2新增评价画像相关-3-6-03新增牵头部门-组织内部门身份名称不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getIsDisplay(),"D3-2新增评价画像相关-3-6-03新增牵头部门-是否外部展示不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getTableTypeCode(),"D3-2新增评价画像相关-3-6-03新增牵头部门-冗余内容表类型编码不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getEntityId(),"D3-2新增评价画像相关-3-6-03新增牵头部门-冗余内容表主键ID不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getEvaluationTemplateType(),"D3-2新增评价画像相关-3-6-03新增牵头部门-归属对象类型不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-6-03新增牵头部门-归属对象ID不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getBatchCode(),"D3-2新增评价画像相关-3-6-03新增牵头部门-批次标识不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getCreateBatchCode(),"D3-2新增评价画像相关-3-6-03新增牵头部门-创建于批次标识不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getUseScene(),"D3-2新增评价画像相关-3-6-03新增牵头部门-虚拟组织使用场景不能为空",false);
Assert.isNull(omsVirtualOrgMemberDept.getOrderNumber(),"D3-2新增评价画像相关-3-6-03新增牵头部门-排序不能为空",false);
      string_6 = mOmsVirtualOrgMemberDeptService.addVirtualOrgMemberDept(omsVirtualOrgMemberDept)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_7 = string_6;
           }
    
//步骤8: D1-3查询个人就职记录信息详情（公共） - queryInductionRecordInfoDetailCom
     QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
    QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto=new QueryInductionRecordInfoDetailComReqDto();
  queryInductionRecordInfoDetailComReqDto.setInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:108863_1
queryInductionRecordInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:315169_1
  
    /*D1-3查询个人就职记录信息详情（公共）[715]   */
Assert.isNull(queryInductionRecordInfoDetailComReqDto.getSpaceId(),"D3-2新增评价画像相关-D1-3查询个人就职记录信息详情（公共）-创建于空间ID不能为空",false);
      queryInductionRecordInfoDetailComRespDto = fwBaseInductionRecordClient.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryInductionRecordInfoDetailComRespDto== null||  queryInductionRecordInfoDetailComRespDto.getInductionRecordId() ==null,"找不到数据，系统异常",false);
      
      
    
//步骤9: 3-6-02新增虚拟组织成员 - addVirtualOrgMember
     String string_8 = null;
    if(string_4 !=null){
          OmsVirtualOrgMember omsVirtualOrgMember=new OmsVirtualOrgMember();
  omsVirtualOrgMember.setRoleCode("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:107307_1
omsVirtualOrgMember.setVirtualOrganizationPosition("负责人");//CUSTOM_CONVENTION//sourceId:107308_1
omsVirtualOrgMember.setIsAdmin("TRUE");//sourceId:107310_1
omsVirtualOrgMember.setIsUpperLowerLevels("TRUE");//sourceId:167496_1
omsVirtualOrgMember.setIsDirectStakeholders("TRUE");//sourceId:107311_1
omsVirtualOrgMember.setIsPersonCharge("TRUE");//sourceId:107312_1
omsVirtualOrgMember.setIsDisplay("FALSE");//sourceId:107313_1
omsVirtualOrgMember.setTableTypeCode("OMS_TARGET");//sourceId:107314_1
omsVirtualOrgMember.setEvaluationTemplateType("EVA_TEMP");//sourceId:167500_1
omsVirtualOrgMember.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:107319_1
omsVirtualOrgMember.setUseScene("TARGET_PLAN_SCENE");//sourceId:1559828_1
if(string_4!=null){
      omsVirtualOrgMember.setVirtualOrgId(string_4);//SimpleFieldAssign//sourceId:107304_1
    }
if(queryInductionRecordInfoDetailComRespDto!=null){
      omsVirtualOrgMember.setVirtualOrgInductionRecordId(queryInductionRecordInfoDetailComRespDto.getInductionRecordId());//SimpleFieldAssign//sourceId:107305_1
omsVirtualOrgMember.setUserId(queryInductionRecordInfoDetailComRespDto.getUserId());//SimpleFieldAssign//sourceId:107306_1
omsVirtualOrgMember.setFirstLetter(queryInductionRecordInfoDetailComRespDto.getFirstLetter());//SimpleFieldAssign//sourceId:107318_1
omsVirtualOrgMember.setOriginalRoleMemberId(queryInductionRecordInfoDetailComRespDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:374845_1
    }
if(implementWorkGroupStartTimeComRespDto!=null){
      omsVirtualOrgMember.setInductionStartTime(implementWorkGroupStartTimeComRespDto.getComTimeField());//SimpleFieldAssign//sourceId:379977_1
    }
if(omsEvaluationTemplate!=null){
      omsVirtualOrgMember.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:107315_1
omsVirtualOrgMember.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:158731_1
omsVirtualOrgMember.setBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:107316_1
omsVirtualOrgMember.setCreateBatchCode(omsEvaluationTemplate.getBatchCode());//SimpleFieldAssign//sourceId:1559829_1
}
  
    /*3-6-02新增负责人[2353]   */
    Assert.isNull(omsVirtualOrgMember.getVirtualOrgId(),"D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织ID不能为空",false);
Assert.isNull(omsVirtualOrgMember.getVirtualOrgInductionRecordId(),"D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织成员就职记录ID不能为空",false);
Assert.isNull(omsVirtualOrgMember.getUserId(),"D3-2新增评价画像相关-3-6-02新增负责人-个人账号不能为空",false);
Assert.isNull(omsVirtualOrgMember.getFirstLetter(),"D3-2新增评价画像相关-3-6-02新增负责人-备注首位字母不能为空",false);
Assert.isNull(omsVirtualOrgMember.getOriginalRoleMemberId(),"D3-2新增评价画像相关-3-6-02新增负责人-身份人员ID不能为空",false);
Assert.isNull(omsVirtualOrgMember.getRoleCode(),"D3-2新增评价画像相关-3-6-02新增负责人-角色标识不能为空",false);
Assert.isNull(omsVirtualOrgMember.getVirtualOrganizationPosition(),"D3-2新增评价画像相关-3-6-02新增负责人-组内职务名称不能为空",false);
Assert.isNull(omsVirtualOrgMember.getIsAdmin(),"D3-2新增评价画像相关-3-6-02新增负责人-是否管理员不能为空",false);
Assert.isNull(omsVirtualOrgMember.getIsUpperLowerLevels(),"D3-2新增评价画像相关-3-6-02新增负责人-是否上下级关系不能为空",false);
Assert.isNull(omsVirtualOrgMember.getIsDirectStakeholders(),"D3-2新增评价画像相关-3-6-02新增负责人-是否直接干系人不能为空",false);
Assert.isNull(omsVirtualOrgMember.getIsPersonCharge(),"D3-2新增评价画像相关-3-6-02新增负责人-是否负责人不能为空",false);
Assert.isNull(omsVirtualOrgMember.getIsDisplay(),"D3-2新增评价画像相关-3-6-02新增负责人-是否外部展示不能为空",false);
Assert.isNull(omsVirtualOrgMember.getEntityId(),"D3-2新增评价画像相关-3-6-02新增负责人-冗余内容表主键ID不能为空",false);
Assert.isNull(omsVirtualOrgMember.getTableTypeCode(),"D3-2新增评价画像相关-3-6-02新增负责人-冗余内容表类型编码不能为空",false);
Assert.isNull(omsVirtualOrgMember.getEvaluationTemplateId(),"D3-2新增评价画像相关-3-6-02新增负责人-归属对象ID不能为空",false);
Assert.isNull(omsVirtualOrgMember.getEvaluationTemplateType(),"D3-2新增评价画像相关-3-6-02新增负责人-归属对象类型不能为空",false);
Assert.isNull(omsVirtualOrgMember.getOrderNumber(),"D3-2新增评价画像相关-3-6-02新增负责人-排序不能为空",false);
Assert.isNull(omsVirtualOrgMember.getUseScene(),"D3-2新增评价画像相关-3-6-02新增负责人-虚拟组织使用场景不能为空",false);
Assert.isNull(omsVirtualOrgMember.getBatchCode(),"D3-2新增评价画像相关-3-6-02新增负责人-批次标识不能为空",false);
Assert.isNull(omsVirtualOrgMember.getCreateBatchCode(),"D3-2新增评价画像相关-3-6-02新增负责人-创建于批次标识不能为空",false);
      string_8 = mOmsVirtualOrgMemberService.addVirtualOrgMember(omsVirtualOrgMember)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_9 = string_8;
           }

//步骤10: 3-6-02修改虚拟组织成员 - updateVirtualOrgMember
     boolean bOOLEAN ;
    if(string_8 !=null){
          OmsVirtualOrgMember omsVirtualOrgMember_1=new OmsVirtualOrgMember();
  omsVirtualOrgMember_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:869249_1
if(string_8!=null){
      omsVirtualOrgMember_1.setVirtualOrgMemberId(string_8);//SimpleFieldAssign//sourceId:869248_1
    }

    /*3-6-02更新管理员为当前有效[2612]   */
    Assert.isNull(omsVirtualOrgMember_1.getVirtualOrgMemberId(),"D3-2新增评价画像相关-3-6-02更新管理员为当前有效-虚拟组织成员ID不能为空",false);
Assert.isNull(omsVirtualOrgMember_1.getSubjectLifeCycle(),"D3-2新增评价画像相关-3-6-02更新管理员为当前有效-主体生命周期不能为空",false);
      bOOLEAN = mOmsVirtualOrgMemberService.updateVirtualOrgMember(omsVirtualOrgMember_1)/*vcase invoke 本地 method 方法调用;*/;



           }

AddEvaPortraitRelatedRespDto retData = new AddEvaPortraitRelatedRespDto();
  if(string_1!=null){
      retData.setEvaluationPortraitId(string_1);//SimpleFieldAssign//sourceId:376035_1
    }
if(string_3!=null){
      retData.setEvaluationObjectId(string_3);//SimpleFieldAssign//sourceId:108783_1
    }
if(addEvaFillRoleComRespDto_1!=null){
      retData.setEvaluationFillRoleId(addEvaFillRoleComRespDto_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:376040_1
    }
if(string_5!=null){
      retData.setVirtualOrgId(string_5);//SimpleFieldAssign//sourceId:108779_1
    }
if(string_7!=null){
      retData.setVirtualOrgMemberDeptId(string_7);//SimpleFieldAssign//sourceId:108780_1
    }
if(string_9!=null){
      retData.setVirtualOrgMemberId(string_9);//SimpleFieldAssign//sourceId:108781_1
    }
  

  
  
return retData;
  }
/**
   * D3-2发布批次处理评价模板更新状态(公共)[3617]
   * gen by moon at 10/27/2022, 4:16:52 PM
   */
  @Trace(operationName = "D3-2发布批次处理评价模板更新状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseBatchHandleEvaTempUpdStatusComRespDto releaseBatchHandleEvaTempUpdStatusCom(ReleaseBatchHandleEvaTempUpdStatusComReqDto reqDto){
    
      
      //virtualUsage 3-2-02查评价模板详情  10327
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setUpdateStatus("NEW");//sourceId:162486_1_10327
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:162396_1_10327
queryEvaTempDetailReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:162424_1_10327
    }
  
    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getBatchCode(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02查评价模板详情-批次标识不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getUpdateStatus(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02查评价模板详情-批次下更新状态不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq);
      
      
      
if((omsEvaluationTemplate != null )) {
        //if(3-2-02查批次下是否有正在编辑评价模板.出参 值不等于空 )  10328
        
boolean bOOLEAN ;
    if(omsEvaluationTemplate !=null){
          OmsEvaluationTemplate omsEvaluationTemplate_2=new OmsEvaluationTemplate();
  omsEvaluationTemplate_2.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:162432_1_10329
omsEvaluationTemplate_2.setIsUpdate("FALSE");//sourceId:162433_1_10329
omsEvaluationTemplate_2.setUpdateStatus("UNCHANGED");//sourceId:162434_1_10329
omsEvaluationTemplate_2.setIsEditing("FALSE");//sourceId:162435_1_10329
omsEvaluationTemplate_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:162436_1_10329
omsEvaluationTemplate_2.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:162482_1_10329
omsEvaluationTemplate_2.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:162483_1_10329
if(omsEvaluationTemplate!=null){
      omsEvaluationTemplate_2.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:162420_1_10329
    }
  
    /*3-2-02修改评价模板[2393]   */
    Assert.isNull(omsEvaluationTemplate_2.getEvaluationTemplateId(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getBatchStartTime(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次开始时间不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getIsUpdate(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次下是否更新不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getUpdateStatus(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-批次下更新状态不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getIsEditing(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-是否未来不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getSubjectLifeCycle(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-主体生命周期不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getReleaseInductionId(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-发布人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationTemplate_2.getReleaseTime(),"D3-2发布批次处理评价模板更新状态(公共)-3-2-02修改评价模板-发布时间不能为空",false);
      bOOLEAN = mOmsEvaluationTemplateService.updateEvaTemp(omsEvaluationTemplate_2);
      
      
      
           }
//processBranchName:正常结束 ,processBranchId:10330
        
      }
ReleaseBatchHandleEvaTempUpdStatusComRespDto retData = new ReleaseBatchHandleEvaTempUpdStatusComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2检查是否参与评价工作[3228]
   * gen by moon at 11/30/2022, 2:32:39 AM
   */
  @Trace(operationName = "D3-2检查是否参与评价工作")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CheckIsOpenEvaRespDto checkIsOpenEva(CheckIsOpenEvaReqDto reqDto){
    
      
      AddOutputParametersRespDto receptionServiceRes_1 =null;
ImplementOutputParametersRespDto receptionServiceRes_3 =null;
//virtualUsage D2-3查询配置项匹配结果转答案(是否开启评价工作)  6665
      QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
    QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto=new QueryItemMatchResultToAnswerDetailComReqDto();
  queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("IS_OPEN_EVA_WORK");//CUSTOM_CONVENTION//sourceId:122981_1_6665
queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:122982_1_6665
queryItemMatchResultToAnswerDetailComReqDto.setIsInitialScheme("TRUE");//sourceId:308471_1_6665
queryItemMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:308472_1_6665
if(reqDto!=null){
      queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122983_1_6665
    }

    /*D2-3查询配置项匹配结果转答案(是否开启评价工作)[3094]   */
    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-答案归属对象ID不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(),"D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-配置项标识不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(),"D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-答案归属对象类型不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsInitialScheme(),"D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-是否初始方案答案不能为空",false);
Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-2检查是否参与评价工作-D2-3查询配置项匹配结果转答案(是否开启评价工作)-是否标准答案不能为空",false);
      queryItemMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();
      
      
      
//virtualUsage 3-6-02查虚拟组织成员列表  6666
      List<OmsVirtualOrgMember> listOmsVirtualOrgMember =new ArrayList<>();
    QueryVirtualOrgMemberListReq queryVirtualOrgMemberListReq=new QueryVirtualOrgMemberListReq();
  queryVirtualOrgMemberListReq.setVirtualOrgInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:122747_1_6666
queryVirtualOrgMemberListReq.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:122741_1_6666
queryVirtualOrgMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:122742_1_6666
if(reqDto!=null){
      queryVirtualOrgMemberListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:122750_1_6666
    }

    /*3-6-02查虚拟组织成员列表[2201]   */
    Assert.isNull(queryVirtualOrgMemberListReq.getEntityId(),"D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getVirtualOrgInductionRecordId(),"D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-虚拟组织成员就职记录ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getTableTypeCode(),"D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getSubjectLifeCycle(),"D3-2检查是否参与评价工作-3-6-02查虚拟组织成员列表-主体生命周期不能为空",false);
      listOmsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberList(queryVirtualOrgMemberListReq);
      
      
      
//virtualUsage 3-2-06查询评价填报角色列表ByCodes  6667
      List<OmsEvaluationFillRole> listOmsEvaluationFillRole =new ArrayList<>();
    if(listOmsVirtualOrgMember !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMember)&& listOmsVirtualOrgMember.size()>0 ){
          BatchQueryEvaFillRoleListByCodesReq batchQueryEvaFillRoleListByCodesReq=new BatchQueryEvaFillRoleListByCodesReq();
  batchQueryEvaFillRoleListByCodesReq.setEvaFillRoleList(listOmsVirtualOrgMember.stream().map(item->item.getRoleCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:122734_1_6667
if(reqDto!=null){
      batchQueryEvaFillRoleListByCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122735_1_6667
batchQueryEvaFillRoleListByCodesReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:122737_1_6667
    }
  
    /*3-2-06查询评价填报角色列表ByCodes[3230]   */
    Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getEvaluationTemplateId(),"D3-2检查是否参与评价工作-3-2-06查询评价填报角色列表ByCodes-评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getRoleTypeCode(),"D3-2检查是否参与评价工作-3-2-06查询评价填报角色列表ByCodes-评价填报角色类型编码不能为空",false);
      listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.batchQueryEvaFillRoleListByCodes(batchQueryEvaFillRoleListByCodesReq);
      
      
      
           }
if((queryItemMatchResultToAnswerDetailComRespDto!= null&&  queryItemMatchResultToAnswerDetailComRespDto.getIsOpenEvaWork() !=null && queryItemMatchResultToAnswerDetailComRespDto.getIsOpenEvaWork().equals("TRUE")&&listOmsEvaluationFillRole!= null&&  listOmsEvaluationFillRole !=null && listOmsEvaluationFillRole.size()>0)) {
        //if((D2-3查询配置项匹配结果转答案(是否开启评价工作).是否开启评价工作 等于 是 and 3-2-06查询评价填报角色列表ByCodes.评价填报角色列表数据集条数 大于 0))  6668
        
//ModelCode: receptionService
        AddOutputParametersRespDto receptionServiceRes = null;
    AddOutputParametersReqDto receptionServiceReq=new AddOutputParametersReqDto();
  receptionServiceReq.setIsOpenEvaWork("TRUE");//sourceId:312650_1_6669
  
    /*模板开启评价工作[2888] 第一个分支返回：TRUE，第二个分支返回：FALSE 用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaTheme.addOutputParameters(receptionServiceReq);

      
      receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15911

      }
else{
       //else  6670
      
//ModelCode: receptionService
        ImplementOutputParametersRespDto receptionServiceRes_2 = null;
    ImplementOutputParametersReqDto receptionServiceReq_1=new ImplementOutputParametersReqDto();
  receptionServiceReq_1.setIsOpenEvaWork("FALSE");//sourceId:312658_1_15910

    /*模板未开启评价工作[2888]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsOpenEvaWork(),"D3-2检查是否参与评价工作-模板未开启评价工作-是否开启评价工作不能为空",false);
      receptionServiceRes_2 = nbEvaTheme.implementOutputParameters(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
//processBranchName:正常结束 ,processBranchId:15912

    }
CheckIsOpenEvaRespDto retData = new CheckIsOpenEvaRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsOpenEvaWork(receptionServiceRes_1.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
    }
if(receptionServiceRes_3!=null){
      retData.setIsOpenEvaWork(receptionServiceRes_3.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
    }
  

  
  
return retData;
  }
/**
   * D3-3新增评价模板判断[4500]
   * gen by moon at 5/6/2023, 3:08:47 PM
   */
  @Trace(operationName = "D3-3新增评价模板判断")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryAddEvaTempJudgeDetailRespDto queryAddEvaTempJudgeDetail(QueryAddEvaTempJudgeDetailReqDto reqDto){
    
      
      ObtainReceiveOutFieldRespDto receptionServiceRes_1 =null;
QuerySchemeImpowerCaseDetailComRespDto querySchemeImpowerCaseDetailComRespDto_1 =null;
//virtualUsage D1-2查询当前用户就职记录权限(公共)  16194
      QueryCurrentUserRecordTributPowerDetailComRespDto queryCurrentUserRecordTributPowerDetailComRespDto = null;
    QueryCurrentUserRecordTributPowerDetailComReqDto queryCurrentUserRecordTributPowerDetailComReqDto=new QueryCurrentUserRecordTributPowerDetailComReqDto();
  queryCurrentUserRecordTributPowerDetailComReqDto.setAllocationObjectId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:322917_1_16194
queryCurrentUserRecordTributPowerDetailComReqDto.setTypeCode("PERSONAL_DEPARTMENT");//sourceId:332224_1_16194
queryCurrentUserRecordTributPowerDetailComReqDto.setPrivacyCategory("SUB_DATA_PRIVACY");//sourceId:332225_1_16194
queryCurrentUserRecordTributPowerDetailComReqDto.setBusinessPurposes("ALL");//sourceId:332226_1_16194
if(reqDto!=null){
      queryCurrentUserRecordTributPowerDetailComReqDto.setPrivacyCode(reqDto.getPrivacyCode());//SimpleFieldAssign//sourceId:322920_1_16194
    }
  
    /*D1-2查询当前用户就职记录权限(公共)[4546]   */
    Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getPrivacyCode(),"D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限标识不能为空",false);
Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getAllocationObjectId(),"D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-分配对象ID不能为空",false);
Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getTypeCode(),"D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-分配对象类型编码不能为空",false);
Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getPrivacyCategory(),"D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限类别不能为空",false);
Assert.isNull(queryCurrentUserRecordTributPowerDetailComReqDto.getBusinessPurposes(),"D3-3新增评价模板判断-D1-2查询当前用户就职记录权限(公共)-权限业务用途不能为空",false);
      queryCurrentUserRecordTributPowerDetailComRespDto = fwBasePowerClient.queryCurrentUserRecordTributPowerDetailCom(queryCurrentUserRecordTributPowerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;

      
      
if((queryCurrentUserRecordTributPowerDetailComRespDto!= null&& queryCurrentUserRecordTributPowerDetailComRespDto.getPrivacyCode() != null )) {
        //if(D1-2查询当前用户就职记录权限(公共).权限标识 值不等于空 )  19351
        
//ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  receptionServiceReq.setOutputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:374677_1_19352
  
    /*M3有新增模板权限[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOutputNum(),"D3-3新增评价模板判断-M3有新增模板权限-传输数值（整数型）不能为空",false);
      receptionServiceRes = nbEvaTheme.obtainReceiveOutField(receptionServiceReq);
      
      
      receptionServiceRes_1 = receptionServiceRes;
      }
//virtualUsage D2-3查询方案授权情况(公共)  16517
      QuerySchemeImpowerCaseDetailComRespDto querySchemeImpowerCaseDetailComRespDto = null;
    QuerySchemeImpowerCaseDetailComReqDto querySchemeImpowerCaseDetailComReqDto=new QuerySchemeImpowerCaseDetailComReqDto();
  if(reqDto!=null){
      querySchemeImpowerCaseDetailComReqDto.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:333728_1_16517
    }
  
    /*D2-3查询方案授权情况(公共)[4584]   */
    Assert.isNull(querySchemeImpowerCaseDetailComReqDto.getConfSchemeCode(),"D3-3新增评价模板判断-D2-3查询方案授权情况(公共)-配置方案标识不能为空",false);
      querySchemeImpowerCaseDetailComRespDto = fwCompSchemeOpenRecordClient.querySchemeImpowerCaseDetailCom(querySchemeImpowerCaseDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      querySchemeImpowerCaseDetailComRespDto_1 = querySchemeImpowerCaseDetailComRespDto;
//processBranchName:正常结束 ,processBranchId:24368

QueryAddEvaTempJudgeDetailRespDto retData = new QueryAddEvaTempJudgeDetailRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsVisible(receptionServiceRes_1.getOutputNum());//SimpleFieldAssign//sourceId:499221_1
    }
if(querySchemeImpowerCaseDetailComRespDto_1!=null){
      retData.setIsUsable(querySchemeImpowerCaseDetailComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:499220_1
retData.setEndValue(querySchemeImpowerCaseDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:333740_1
    }
  

  
  
return retData;
  }
/**
   * D3-删除评价填报人员(公共)[4598]
   * gen by moon at 5/5/2023, 10:03:23 PM
   */
  @Trace(operationName = "D3-删除评价填报人员(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteEvaFillMemberComRespDto deleteEvaFillMemberCom(DeleteEvaFillMemberComReqDto reqDto){
    
      
      //步骤0: 3-2-07查询评价填报人员列表 - queryEvaFillMemberList
     List<OmsEvaluationFillMember> listOmsEvaluationFillMember =new ArrayList<>();
    OmsEvaluationFillMember omsEvaluationFillMember=new OmsEvaluationFillMember();
  if(reqDto!=null){
      omsEvaluationFillMember.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334582_1
    }
  
    /*3-2-07查询评价填报人员列表[4215]   */
    Assert.isNull(omsEvaluationFillMember.getEvaluationTemplateId(),"D3-删除评价填报人员(公共)-3-2-07查询评价填报人员列表-评价模板ID不能为空",false);
      listOmsEvaluationFillMember = mOmsEvaluationFillMemberService.queryEvaFillMemberList(omsEvaluationFillMember)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: 3-2-07批量删评价填报人员 - batchDeleteEvaFillMember
     boolean bOOLEAN ;
    if(listOmsEvaluationFillMember !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillMember)&& listOmsEvaluationFillMember.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsEvaluationFillMember!= null&& !CollectionUtil.isEmpty(listOmsEvaluationFillMember)&&  listOmsEvaluationFillMember !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillMember)){
  listString = listOmsEvaluationFillMember.stream().map(item->item.getEvaluationFillMemberId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:334584_1
    }

    /*3-2-07批量删评价填报人员[4217]   */
    
      bOOLEAN = mOmsEvaluationFillMemberService.batchDeleteEvaFillMember(listString)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
DeleteEvaFillMemberComRespDto retData = new DeleteEvaFillMemberComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-删除评价填报角色(公共)[4597]
   * gen by moon at 5/5/2023, 10:03:26 PM
   */
  @Trace(operationName = "D3-删除评价填报角色(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteEvaFillRoleComRespDto deleteEvaFillRoleCom(DeleteEvaFillRoleComReqDto reqDto){
    
      
      //步骤0: 3-2-06查评价填报角色列表 - queryEvaFillRoleList
     List<OmsEvaluationFillRole> listOmsEvaluationFillRole =new ArrayList<>();
    QueryEvaFillRoleListReq queryEvaFillRoleListReq=new QueryEvaFillRoleListReq();
  if(reqDto!=null){
      queryEvaFillRoleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334574_1
    }
  
    /*3-2-06查评价填报角色列表[2369]   */
    Assert.isNull(queryEvaFillRoleListReq.getEvaluationTemplateId(),"D3-删除评价填报角色(公共)-3-2-06查评价填报角色列表-评价模板ID不能为空",false);
      listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleList(queryEvaFillRoleListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: 3-2-06批量删评价填报角色 - batchDeleteEvaFillRole
     boolean bOOLEAN ;
    if(listOmsEvaluationFillRole !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)&& listOmsEvaluationFillRole.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsEvaluationFillRole!= null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)&&  listOmsEvaluationFillRole !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)){
  listString = listOmsEvaluationFillRole.stream().map(item->item.getEvaluationFillRoleId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:334579_1
    }

    /*3-2-06批量删评价填报角色[4213]   */
    
      bOOLEAN = mOmsEvaluationFillRoleService.batchDeleteEvaFillRole(listString)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
DeleteEvaFillRoleComRespDto retData = new DeleteEvaFillRoleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-删除评价对象(公共)[4596]
   * gen by moon at 3/5/2023, 9:33:41 PM
   */
  @Trace(operationName = "D3-删除评价对象(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteEvaObjectComRespDto deleteEvaObjectCom(DeleteEvaObjectComReqDto reqDto){
    
      
      //步骤0: 3-2-05查询评价对象详情 - queryEvaObjectDetail
     OmsEvaluationObject omsEvaluationObject = null;
    QueryEvaObjectDetailReq queryEvaObjectDetailReq=new QueryEvaObjectDetailReq();
  if(reqDto!=null){
      queryEvaObjectDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334569_1
    }
  
    /*3-2-05查询评价对象详情[3463]   */
    Assert.isNull(queryEvaObjectDetailReq.getEvaluationTemplateId(),"D3-删除评价对象(公共)-3-2-05查询评价对象详情-评价模板ID不能为空",false);
      omsEvaluationObject = mOmsEvaluationObjectService.queryEvaObjectDetail(queryEvaObjectDetailReq);
      
      
      
    
//步骤1: 3-2-05删除评价对象 - deleteEvaObject
     boolean bOOLEAN ;
    if(omsEvaluationObject !=null){
          String string=new String();
  if(omsEvaluationObject!=null){
      string=omsEvaluationObject.getEvaluationObjectId();;//SimpleFieldAssign//sourceId:334571_1
    }
  
    /*3-2-05删除评价对象[4210]   */
    Assert.isNull(string,"D3-删除评价对象(公共)-3-2-05删除评价对象-评价对象ID不能为空",false);
      bOOLEAN = mOmsEvaluationObjectService.deleteEvaObject(string);
      
      
      
           }
    
DeleteEvaObjectComRespDto retData = new DeleteEvaObjectComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-3返回评价模板第一步[4609]
   * gen by moon at 5/26/2023, 3:38:36 AM
   */
  @Trace(operationName = "D3-3返回评价模板第一步")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BackToFirstStepEvaTempRespDto backToFirstStepEvaTemp(BackToFirstStepEvaTempReqDto reqDto){
    
      
      //步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
     OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setSubjectLifeCycle("EDITING");//sourceId:334518_1
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334517_1
    }
  
    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationSubjectId(),"D3-3返回评价模板第一步-3-2-02查评价模板详情-归属评价主题ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-3返回评价模板第一步-3-2-02查评价模板详情-主体生命周期不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationTemplate== null||  omsEvaluationTemplate.getEvaluationTemplateId() ==null,"找不到数据，系统异常",false);
      
      
    
//步骤1: D3-删除目标(公共) - deleteTargetCom
     DeleteTargetComRespDto deleteTargetComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteTargetComReqDto deleteTargetComReqDto=new DeleteTargetComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteTargetComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:985002_1
    }

    /*D3-删除目标(公共)[4592]   */
    Assert.isNull(deleteTargetComReqDto.getTargetId(),"D3-3返回评价模板第一步-D3-删除目标(公共)-目标ID不能为空",false);
      deleteTargetComRespDto = indexSystemService.deleteTargetCom(deleteTargetComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤2: D3-删除评价模板批次设置(公共) - deletePlanEvaBatchSetCom
     DeletePlanEvaBatchSetComRespDto deletePlanEvaBatchSetComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeletePlanEvaBatchSetComReqDto deletePlanEvaBatchSetComReqDto=new DeletePlanEvaBatchSetComReqDto();
  if(omsEvaluationTemplate!=null){
      deletePlanEvaBatchSetComReqDto.setBatchSetId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334542_1
    }
  
    /*D3-删除评价模板批次设置(公共)[4589]   */
    Assert.isNull(deletePlanEvaBatchSetComReqDto.getBatchSetId(),"D3-3返回评价模板第一步-D3-删除评价模板批次设置(公共)-批次设置对象ID不能为空",false);
      deletePlanEvaBatchSetComRespDto = batchService.deletePlanEvaBatchSetCom(deletePlanEvaBatchSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤3: D3-删除业务应用批次(公共) - deleteBizAppBatchCom
     DeleteBizAppBatchComRespDto deleteBizAppBatchComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteBizAppBatchComReqDto deleteBizAppBatchComReqDto=new DeleteBizAppBatchComReqDto();
  deleteBizAppBatchComReqDto.setPurposeTypeCode("TOP_EVA_TEMP_MGT");//sourceId:334544_1
if(omsEvaluationTemplate!=null){
      deleteBizAppBatchComReqDto.setAscriptionObjectId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334545_1
    }
  
    /*D3-删除业务应用批次(公共)[3606]   */
    Assert.isNull(deleteBizAppBatchComReqDto.getAscriptionObjectId(),"D3-3返回评价模板第一步-D3-删除业务应用批次(公共)-归属对象ID不能为空",false);
Assert.isNull(deleteBizAppBatchComReqDto.getPurposeTypeCode(),"D3-3返回评价模板第一步-D3-删除业务应用批次(公共)-用途类型编码不能为空",false);
      deleteBizAppBatchComRespDto = batchService.deleteBizAppBatchCom(deleteBizAppBatchComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤4: D3-6删除目标内容虚拟圈子信息(公共) - deleteTargetContVirtualOrgInfoCom
     DeleteTargetContVirtualOrgInfoComRespDto deleteTargetContVirtualOrgInfoComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteTargetContVirtualOrgInfoComReqDto deleteTargetContVirtualOrgInfoComReqDto=new DeleteTargetContVirtualOrgInfoComReqDto();
  deleteTargetContVirtualOrgInfoComReqDto.setTableTypeCode("OMS_TARGET");//sourceId:373865_1
if(omsEvaluationTemplate!=null){
      deleteTargetContVirtualOrgInfoComReqDto.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:373866_1
    }
  
    /*D3-6删除目标内容虚拟圈子信息(公共)[4793]   */
    Assert.isNull(deleteTargetContVirtualOrgInfoComReqDto.getTableTypeCode(),"D3-3返回评价模板第一步-D3-6删除目标内容虚拟圈子信息(公共)-内容表类型编码不能为空",false);
Assert.isNull(deleteTargetContVirtualOrgInfoComReqDto.getEntityId(),"D3-3返回评价模板第一步-D3-6删除目标内容虚拟圈子信息(公共)-内容表主键ID不能为空",false);
      deleteTargetContVirtualOrgInfoComRespDto = virtualOrgService.deleteTargetContVirtualOrgInfoCom(deleteTargetContVirtualOrgInfoComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤5: D3-11删除目标内容检查项状态等(公共) - deleteTargetContentCheckItemStatEtcCom
     DeleteTargetContentCheckItemStatEtcComRespDto deleteTargetContentCheckItemStatEtcComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteTargetContentCheckItemStatEtcComReqDto deleteTargetContentCheckItemStatEtcComReqDto=new DeleteTargetContentCheckItemStatEtcComReqDto();
  deleteTargetContentCheckItemStatEtcComReqDto.setTableTypeCode("OMS_TARGET");//sourceId:373873_1
if(omsEvaluationTemplate!=null){
      deleteTargetContentCheckItemStatEtcComReqDto.setEntityId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:373874_1
    }
  
    /*D3-11删除目标内容检查项状态等(公共)[4794]   */
    Assert.isNull(deleteTargetContentCheckItemStatEtcComReqDto.getTableTypeCode(),"D3-3返回评价模板第一步-D3-11删除目标内容检查项状态等(公共)-内容表类型编码不能为空",false);
Assert.isNull(deleteTargetContentCheckItemStatEtcComReqDto.getEntityId(),"D3-3返回评价模板第一步-D3-11删除目标内容检查项状态等(公共)-内容表主键ID不能为空",false);
      deleteTargetContentCheckItemStatEtcComRespDto = offStateService.deleteTargetContentCheckItemStatEtcCom(deleteTargetContentCheckItemStatEtcComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤6: D3-删除当前规划资料(公共) - deleteCurrentPlanDataCom
     DeleteCurrentPlanDataComRespDto deleteCurrentPlanDataComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteCurrentPlanDataComReqDto deleteCurrentPlanDataComReqDto=new DeleteCurrentPlanDataComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteCurrentPlanDataComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334982_1
    }
  
    /*D3-删除当前规划资料(公共)[4594]   */
    Assert.isNull(deleteCurrentPlanDataComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-删除当前规划资料(公共)-冗余评价模板ID不能为空",false);
      deleteCurrentPlanDataComRespDto = planDataService.deleteCurrentPlanDataCom(deleteCurrentPlanDataComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤7: D3-2删除评价画像(公共) - deleteEvaPortraitCom
     DeleteEvaPortraitComRespDto deleteEvaPortraitComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaPortraitComReqDto deleteEvaPortraitComReqDto=new DeleteEvaPortraitComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteEvaPortraitComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375583_1
    }
  
    /*D3-2删除评价画像(公共)[4829]   */
    Assert.isNull(deleteEvaPortraitComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-2删除评价画像(公共)-评价模板ID不能为空",false);
      deleteEvaPortraitComRespDto = deleteEvaPortraitCom(deleteEvaPortraitComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    
//步骤8: D3-删除评价对象(公共) - deleteEvaObjectCom
     DeleteEvaObjectComRespDto deleteEvaObjectComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaObjectComReqDto deleteEvaObjectComReqDto=new DeleteEvaObjectComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteEvaObjectComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334572_1
    }
  
    /*D3-删除评价对象(公共)[4596]   */
    Assert.isNull(deleteEvaObjectComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-删除评价对象(公共)-评价模板ID不能为空",false);
      deleteEvaObjectComRespDto = deleteEvaObjectCom(deleteEvaObjectComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    
//步骤9: D3-删除评价填报角色(公共) - deleteEvaFillRoleCom
     DeleteEvaFillRoleComRespDto deleteEvaFillRoleComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaFillRoleComReqDto deleteEvaFillRoleComReqDto=new DeleteEvaFillRoleComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteEvaFillRoleComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334581_1
    }
  
    /*D3-删除评价填报角色(公共)[4597]   */
    Assert.isNull(deleteEvaFillRoleComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-删除评价填报角色(公共)-评价模板ID不能为空",false);
      deleteEvaFillRoleComRespDto = deleteEvaFillRoleCom(deleteEvaFillRoleComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    
//步骤10: D3-删除评价填报人员(公共) - deleteEvaFillMemberCom
     DeleteEvaFillMemberComRespDto deleteEvaFillMemberComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaFillMemberComReqDto deleteEvaFillMemberComReqDto=new DeleteEvaFillMemberComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteEvaFillMemberComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334586_1
    }
  
    /*D3-删除评价填报人员(公共)[4598]   */
    Assert.isNull(deleteEvaFillMemberComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-删除评价填报人员(公共)-评价模板ID不能为空",false);
      deleteEvaFillMemberComRespDto = deleteEvaFillMemberCom(deleteEvaFillMemberComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    
//步骤11: D3-3删除被评对象目标周期目标设置(公共) - deleteEvaObjTargetCycleOsetCom
     DeleteEvaObjTargetCycleOsetComRespDto deleteEvaObjTargetCycleOsetComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaObjTargetCycleOsetComReqDto deleteEvaObjTargetCycleOsetComReqDto=new DeleteEvaObjTargetCycleOsetComReqDto();
  deleteEvaObjTargetCycleOsetComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:334660_1
if(omsEvaluationTemplate!=null){
      deleteEvaObjTargetCycleOsetComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334659_1
deleteEvaObjTargetCycleOsetComReqDto.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334658_1
    }
  
    /*D3-3删除被评对象目标周期目标设置(公共)[3246]   */
    Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetId(),"D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-冗余目标ID不能为空",false);
Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetCycleContentId(),"D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-关联目标内容ID不能为空",false);
Assert.isNull(deleteEvaObjTargetCycleOsetComReqDto.getTargetCycleContentTypeCode(),"D3-3返回评价模板第一步-D3-3删除被评对象目标周期目标设置(公共)-关联目标内容类型编码不能为空",false);
      deleteEvaObjTargetCycleOsetComRespDto = targetCycleService.deleteEvaObjTargetCycleOsetCom(deleteEvaObjTargetCycleOsetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤12: D3-3删除执行周期阶段(公共) - deleteExecuteCycleStageCom
     DeleteExecuteCycleStageComRespDto deleteExecuteCycleStageComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteExecuteCycleStageComReqDto deleteExecuteCycleStageComReqDto=new DeleteExecuteCycleStageComReqDto();
  if(omsEvaluationTemplate!=null){
      deleteExecuteCycleStageComReqDto.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:334749_1
    }
  
    /*D3-3删除执行周期阶段(公共)[4612]   */
    Assert.isNull(deleteExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3-3返回评价模板第一步-D3-3删除执行周期阶段(公共)-评价模板ID不能为空",false);
      deleteExecuteCycleStageComRespDto = targetCycleService.deleteExecuteCycleStageCom(deleteExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤13: D3-3删除评价对象被评对象目标周期(公共) - deleteEvaObjTargetCycleCom
     DeleteEvaObjTargetCycleComRespDto deleteEvaObjTargetCycleComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteEvaObjTargetCycleComReqDto deleteEvaObjTargetCycleComReqDto=new DeleteEvaObjTargetCycleComReqDto();
  deleteEvaObjTargetCycleComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:334655_1
if(omsEvaluationTemplate!=null){
      deleteEvaObjTargetCycleComReqDto.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:334657_1
deleteEvaObjTargetCycleComReqDto.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:940377_1
    }

    /*D3-3删除评价对象被评对象目标周期(公共)[3247]   */
    Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetId(),"D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetCycleContentId(),"D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(deleteEvaObjTargetCycleComReqDto.getTargetCycleContentTypeCode(),"D3-3返回评价模板第一步-D3-3删除评价对象被评对象目标周期(公共)-关联目标内容类型编码不能为空",false);
      deleteEvaObjTargetCycleComRespDto = targetCycleService.deleteEvaObjTargetCycleCom(deleteEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤14: D3-2删除定时任务调度(公共) - deleteTimerTaskPlanCom
     DeleteTimerTaskPlanComRespDto deleteTimerTaskPlanComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteTimerTaskPlanComReqDto deleteTimerTaskPlanComReqDto=new DeleteTimerTaskPlanComReqDto();
if(omsEvaluationTemplate!=null){
      deleteTimerTaskPlanComReqDto.setThemeContentId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:940386_1
    }
  
    /*D3-2删除定时任务调度(公共)[3306]   */
    Assert.isNull(deleteTimerTaskPlanComReqDto.getThemeContentId(),"D3-3返回评价模板第一步-D3-2删除定时任务调度(公共)-主题内容ID不能为空",false);
      deleteTimerTaskPlanComRespDto = taskGenService.deleteTimerTaskPlanCom(deleteTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤15: D3-12删除内容当前行为步骤(公共) - deleteContCurrentBstepCom
     DeleteContCurrentBstepComRespDto deleteContCurrentBstepComRespDto = null;
    if(omsEvaluationTemplate !=null){
          DeleteContCurrentBstepComReqDto deleteContCurrentBstepComReqDto=new DeleteContCurrentBstepComReqDto();
  deleteContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_TEMPLATE");//sourceId:374843_1
if(omsEvaluationTemplate!=null){
      deleteContCurrentBstepComReqDto.setEntityId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:374842_1
    }
  
    /*D3-12删除内容当前行为步骤(公共)[4623]   */
    Assert.isNull(deleteContCurrentBstepComReqDto.getEntityId(),"D3-3返回评价模板第一步-D3-12删除内容当前行为步骤(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(deleteContCurrentBstepComReqDto.getStepObj(),"D3-3返回评价模板第一步-D3-12删除内容当前行为步骤(公共)-步骤使用对象表不能为空",false);
      deleteContCurrentBstepComRespDto = offStateService.deleteContCurrentBstepCom(deleteContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;
      

      
           }
    
//步骤16: 3-2-02删除评价模板 - deleteEvaTemp
     boolean bOOLEAN ;
    if(omsEvaluationTemplate !=null){
          String string=new String();
  if(omsEvaluationTemplate!=null){
      string=omsEvaluationTemplate.getEvaluationTemplateId();;//SimpleFieldAssign//sourceId:362179_1
    }
  
    /*3-2-02删除评价模板[4764]   */
    Assert.isNull(string,"D3-3返回评价模板第一步-3-2-02删除评价模板-评价模板ID不能为空",false);
      bOOLEAN = mOmsEvaluationTemplateService.deleteEvaTemp(string)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤17: D2-3查询配置方案详情(公共) - queryConfSchemeDetailCom
     QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto=new QueryConfSchemeDetailComReqDto();
  if(omsEvaluationTemplate!=null){
      queryConfSchemeDetailComReqDto.setConfSchemeCode(omsEvaluationTemplate.getConfSchemeCode());//SimpleFieldAssign//sourceId:381243_1
    }
  
    /*D2-3查询配置方案详情(公共)[1981]   */
    Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeCode(),"D3-3返回评价模板第一步-D2-3查询配置方案详情(公共)-配置方案标识不能为空",false);
      queryConfSchemeDetailComRespDto = fwCompConfSchemeClient.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }

//步骤18: 3-2-01查评价主题详情 - queryEvaThemeDetail
     OmsEvaluationSubject omsEvaluationSubject = null;
    QueryEvaThemeDetailReq queryEvaThemeDetailReq=new QueryEvaThemeDetailReq();
  queryEvaThemeDetailReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:890118_1
if(reqDto!=null){
      queryEvaThemeDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:890125_1
    }

    /*3-2-01查评价主题【配置方案ID】[2310]   */
    Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(),"D3-3返回评价模板第一步-3-2-01查评价主题【配置方案ID】-评价主题ID不能为空",false);
Assert.isNull(queryEvaThemeDetailReq.getAscriptionSpaceId(),"D3-3返回评价模板第一步-3-2-01查评价主题【配置方案ID】-归属空间ID不能为空",false);
      omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤19: D3新增定时任务调度(公共) - addTimerTaskPlanCom
     AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    if(omsEvaluationTemplate !=null){
          AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
  addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:389697_1
addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISATCH_DEL_TEMP_CLONE_RESULT_ETC_TASK");//sourceId:389698_1
addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:389699_1
addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_CONF_SCHEME");//sourceId:389700_1
addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CONF_SCHEME");//sourceId:389703_1
addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:586321_1
addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:389712_1
addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:731013_1
addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:389709_1
addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:389710_1
addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:389711_1
if(omsEvaluationTemplate!=null){
      addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:389696_1
addTimerTaskPlanComReqDto.setThemeContentId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:586322_1
    }
if(queryConfSchemeDetailComRespDto!=null){
      addTimerTaskPlanComReqDto.setObjectId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:389701_1
    }
if(omsEvaluationSubject!=null){
      addTimerTaskPlanComReqDto.setAddRuleInfoId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:389704_1
    }

    /*D3新增模板克隆答案等任务调度(公共)[4995]   */
    Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-目标内容名称不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否补偿任务不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-任务调度的行为类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-任务调度类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-生成规则信息类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-生成辅助规则信息值不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-主题内容类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-主题内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否执行完成不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-是否实时异步调度不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-创建于空间ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAppId(),"D3-3返回评价模板第一步-D3新增模板克隆答案等任务调度(公共)-创建于联盟应用ID不能为空",false);
      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
    
//步骤20: D3-2执行删除模板克隆答案等相关(公共) - implementTempCloneResultEtcCom
     ImplementTempCloneResultEtcComRespDto implementTempCloneResultEtcComRespDto = null;
    if(addTimerTaskPlanComRespDto !=null){
          ImplementTempCloneResultEtcComReqDto implementTempCloneResultEtcComReqDto=new ImplementTempCloneResultEtcComReqDto();
  implementTempCloneResultEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:890427_1
  if(addTimerTaskPlanComRespDto!=null){
      implementTempCloneResultEtcComReqDto.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:890426_1
    }
  
    /*D3-2执行删除模板克隆答案等相关(公共)[4845]   */
    Assert.isNull(implementTempCloneResultEtcComReqDto.getTimingTaskDispatchId(),"D3-3返回评价模板第一步-D3-2执行删除模板克隆答案等相关(公共)-定时任务调度记录ID不能为空",false);
Assert.isNull(implementTempCloneResultEtcComReqDto.getSpaceId(),"D3-3返回评价模板第一步-D3-2执行删除模板克隆答案等相关(公共)-创建于空间ID不能为空",false);
      implementTempCloneResultEtcComRespDto = implementTempCloneResultEtcCom(implementTempCloneResultEtcComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
           }
    
//步骤21: D3-更新业务服务内容当前步骤(公共) - refreshBizAppServiceContCurrentBstepCom
     RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
    RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto=new RefreshBizAppServiceContCurrentBstepComReqDto();
  refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:334723_1
refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:388576_1
refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:388575_1
if(reqDto!=null){
      refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:334675_1
    }
  
    /*D3-更新业务服务内容当前步骤(公共)[4593]   */
    Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(),"D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-步骤内容实例ID不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(),"D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-步骤使用对象表不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(),"D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-业务场景标识不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(),"D3-3返回评价模板第一步-D3-更新业务服务内容当前步骤(公共)-排序不能为空",false);
      refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
BackToFirstStepEvaTempRespDto retData = new BackToFirstStepEvaTempRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2查询评价填报角色详情[3333]
   * gen by moon at 11/15/2022, 11:36:13 AM
   */
  @Trace(operationName = "D3-2查询评价填报角色详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaFillRoleDetailRespDto queryEvaFillRoleDetail(QueryEvaFillRoleDetailReqDto reqDto){


      OmsEvaluationFillRole omsEvaluationFillRole_1 =null;
//步骤0: 3-2-06查评价填报角色详情 - queryEvaFillRoleDetail
     OmsEvaluationFillRole omsEvaluationFillRole = null;
    QueryEvaFillRoleDetailReq queryEvaFillRoleDetailReq=new QueryEvaFillRoleDetailReq();
  if(reqDto!=null){
      queryEvaFillRoleDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:131347_1
queryEvaFillRoleDetailReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:131348_1
queryEvaFillRoleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:131349_1
queryEvaFillRoleDetailReq.setIsSystemType(reqDto.getIsSystemType());//SimpleFieldAssign//sourceId:131350_1
queryEvaFillRoleDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:131351_1
    }

    /*3-2-06查评价填报角色详情[2380]   */

      omsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleDetail(queryEvaFillRoleDetailReq);


      omsEvaluationFillRole_1 = omsEvaluationFillRole;

QueryEvaFillRoleDetailRespDto retData = new QueryEvaFillRoleDetailRespDto();
  if(omsEvaluationFillRole_1!=null){
      retData.setEvaluationFillRoleId(omsEvaluationFillRole_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:131383_1
    }




return retData;
  }
/**
   * D3-2查询评价填报人员详情[4316]
   * gen by moon at 11/15/2022, 11:36:20 AM
   */
  @Trace(operationName = "D3-2查询评价填报人员详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaFillMemberDetailRespDto queryEvaFillMemberDetail(QueryEvaFillMemberDetailReqDto reqDto){


      OmsEvaluationFillMember omsEvaluationFillMember_1 =null;
//步骤0: 3-2-07查询评价填报人员详情 - queryEvaFillMemberDetail
     OmsEvaluationFillMember omsEvaluationFillMember = null;
    QueryEvaFillMemberDetailReq queryEvaFillMemberDetailReq=new QueryEvaFillMemberDetailReq();
  queryEvaFillMemberDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:285133_1
if(reqDto!=null){
      queryEvaFillMemberDetailReq.setEvaluationFillRoleId(reqDto.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:285128_1
//queryEvaFillMemberDetailReq.setMemberId(reqDto.getMemberId());//SimpleFieldAssign//sourceId:285129_1
queryEvaFillMemberDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:285130_1
    }

    /*3-2-07查询评价填报人员详情[4314]   */
    Assert.isNull(queryEvaFillMemberDetailReq.getEvaluationFillRoleId(),"D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-评价填报角色ID不能为空",false);
//Assert.isNull(queryEvaFillMemberDetailReq.getMemberId(),"D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-关联身份人员ID不能为空",false);
Assert.isNull(queryEvaFillMemberDetailReq.getEvaluationTemplateId(),"D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaFillMemberDetailReq.getSubjectLifeCycle(),"D3-2查询评价填报人员详情-3-2-07查询评价填报人员详情-主体生命周期不能为空",false);
      omsEvaluationFillMember = mOmsEvaluationFillMemberService.queryEvaFillMemberDetail(queryEvaFillMemberDetailReq);


      omsEvaluationFillMember_1 = omsEvaluationFillMember;

QueryEvaFillMemberDetailRespDto retData = new QueryEvaFillMemberDetailRespDto();
  if(omsEvaluationFillMember_1!=null){
      retData.setEvaluationFillMemberId(omsEvaluationFillMember_1.getEvaluationFillMemberId());//SimpleFieldAssign//sourceId:285138_1
    }




return retData;
  }
/**
   * D3-3判断新增的评价模板(公共)[4760]
   * gen by moon at 5/1/2023, 10:28:23 PM
   */
  @Trace(operationName = "D3-3判断新增的评价模板(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeAddEvaTempComRespDto judgeAddEvaTempCom(JudgeAddEvaTempComReqDto reqDto){
    
      
      //virtualUsage D3执行评价模板新增条件判断(公共)  38436
      ImplementEvaTempAddTermJudgeComRespDto implementEvaTempAddTermJudgeComRespDto = null;
    ImplementEvaTempAddTermJudgeComReqDto implementEvaTempAddTermJudgeComReqDto=new ImplementEvaTempAddTermJudgeComReqDto();
if(reqDto!=null){
      implementEvaTempAddTermJudgeComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:872602_1_38436
    }
  
    /*D3执行评价模板新增条件判断(公共)[6410]   */
    Assert.isNull(implementEvaTempAddTermJudgeComReqDto.getEvaluationSubjectId(),"D3-3判断新增的评价模板(公共)-D3执行评价模板新增条件判断(公共)-评价主题ID不能为空",false);
      implementEvaTempAddTermJudgeComRespDto = implementEvaTempAddTermJudgeCom(implementEvaTempAddTermJudgeComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
if((implementEvaTempAddTermJudgeComRespDto!= null&& implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() != null &&implementEvaTempAddTermJudgeComRespDto!= null&&  implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() !=null && implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp().equals("0"))) {
        //if((D3执行评价模板新增条件判断(公共).是否允许新增评价模板 值不等于空  and D3执行评价模板新增条件判断(公共).是否允许新增评价模板 等于 0))  38437
        
//异常结束 38438
      throw new BizException("330000219","对不起！当前有未公开的评价模板暂不允许新增，请稍后再试~",false);
      }
else if((implementEvaTempAddTermJudgeComRespDto!= null&& implementEvaTempAddTermJudgeComRespDto.getIsAddEvaTemp() == null )){
       //elseif(D3执行评价模板新增条件判断(公共).是否允许新增评价模板 值等于空 )  38440
      
//异常结束 38441
      throw new BizException("C00091","未知错误，请联系管理员~",false);
    }
JudgeAddEvaTempComRespDto retData = new JudgeAddEvaTempComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2删除评价画像(公共)[4829]
   * gen by moon at 10/15/2022, 5:48:15 PM
   */
  @Trace(operationName = "D3-2删除评价画像(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteEvaPortraitComRespDto deleteEvaPortraitCom(DeleteEvaPortraitComReqDto reqDto){
    
      
      //步骤0: 3-2-04查评价画像详情 - queryEvaPortraitDetail
     OmsEvaluationPortrait omsEvaluationPortrait = null;
    QueryEvaPortraitDetailReq queryEvaPortraitDetailReq=new QueryEvaPortraitDetailReq();
  if(reqDto!=null){
      queryEvaPortraitDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375580_1
    }
  
    /*3-2-04查评价画像详情[2408]   */
    Assert.isNull(queryEvaPortraitDetailReq.getEvaluationTemplateId(),"D3-2删除评价画像(公共)-3-2-04查评价画像详情-评价模板ID不能为空",false);
      omsEvaluationPortrait = mOmsEvaluationPortraitService.queryEvaPortraitDetail(queryEvaPortraitDetailReq);
      
      
      
    
//步骤1: 3-2-04删除评价画像 - deleteEvaPortrait
     boolean bOOLEAN ;
    if(omsEvaluationPortrait !=null){
          String string=new String();
  if(omsEvaluationPortrait!=null){
      string=omsEvaluationPortrait.getEvaluationPortraitId();;//SimpleFieldAssign//sourceId:375550_1
    }
  
    /*3-2-04删除评价画像[4209]   */
    Assert.isNull(string,"D3-2删除评价画像(公共)-3-2-04删除评价画像-评价画像ID不能为空",false);
      bOOLEAN = mOmsEvaluationPortraitService.deleteEvaPortrait(string);
      
      
      
           }
    
DeleteEvaPortraitComRespDto retData = new DeleteEvaPortraitComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2新增评价填报角色(公共)[4830]
   * gen by moon at 11/4/2023, 3:44:12 PM
   */
  @Trace(operationName = "D3-2新增评价填报角色(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddEvaFillRoleComRespDto addEvaFillRoleCom(AddEvaFillRoleComReqDto reqDto){
    
      
      String string_1 =null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
     //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:952855_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:376013_1
receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637755_1
receptionServiceReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:376014_1
    }
  
    /*M3接收字段[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getConfSchemeId(),"D3-2新增评价填报角色(公共)-M3接收字段-配置方案ID 不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-2新增评价填报角色(公共)-M3接收字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationSubjectId(),"D3-2新增评价填报角色(公共)-M3接收字段-冗余评价主题ID不能为空",false);
Assert.isNull(receptionServiceReq.getBatchCode(),"D3-2新增评价填报角色(公共)-M3接收字段-批次标识不能为空",false);
      receptionServiceRes = nbEvaTheme.obtainReceiveOutField(receptionServiceReq);
      
      
      
    
//步骤1: D1-查询角色详情(公共) - queryRoleDetailCom
     QueryRoleDetailComRespDto queryRoleDetailComRespDto = null;
    QueryRoleDetailComReqDto queryRoleDetailComReqDto=new QueryRoleDetailComReqDto();
  queryRoleDetailComReqDto.setRoleCode("INITIATOR");//CUSTOM_CONVENTION//sourceId:375881_1
  
    /*D1-查询角色详情（牵头人）[2747]   */
    Assert.isNull(queryRoleDetailComReqDto.getRoleCode(),"D3-2新增评价填报角色(公共)-D1-查询角色详情（牵头人）-角色标识不能为空",false);
      queryRoleDetailComRespDto = fwBaseRoleClient.queryRoleDetailCom(queryRoleDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
//步骤2: 3-2-06新增评价填报角色 - addEvaFillRole
     String string = null;
    if(queryRoleDetailComRespDto !=null){
          OmsEvaluationFillRole omsEvaluationFillRole=new OmsEvaluationFillRole();
  omsEvaluationFillRole.setRoleTypeCode("APPLICANT");//sourceId:375886_1
omsEvaluationFillRole.setIsSystemType("TRUE");//sourceId:375888_1
omsEvaluationFillRole.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:375889_1
if(queryRoleDetailComRespDto!=null){
      omsEvaluationFillRole.setRoleId(queryRoleDetailComRespDto.getRoleId());//SimpleFieldAssign//sourceId:375892_1
omsEvaluationFillRole.setRoleCode(queryRoleDetailComRespDto.getRoleCode());//SimpleFieldAssign//sourceId:375885_1
omsEvaluationFillRole.setRoleName(queryRoleDetailComRespDto.getRoleName());//SimpleFieldAssign//sourceId:375893_1
    }
if(reqDto!=null){
      omsEvaluationFillRole.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:375887_1
omsEvaluationFillRole.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:637753_1
omsEvaluationFillRole.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:375890_1
    }
  
    /*3-2-06新增填报角色（牵头人）[2449]   */
    Assert.isNull(omsEvaluationFillRole.getRoleId(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色ID不能为空",false);
Assert.isNull(omsEvaluationFillRole.getRoleCode(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色标识不能为空",false);
Assert.isNull(omsEvaluationFillRole.getRoleName(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-普通角色名称不能为空",false);
Assert.isNull(omsEvaluationFillRole.getRoleTypeCode(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-评价填报角色类型编码不能为空",false);
Assert.isNull(omsEvaluationFillRole.getEvaluationTemplateId(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationFillRole.getEvaluationSubjectId(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-冗余评价主题ID不能为空",false);
Assert.isNull(omsEvaluationFillRole.getIsSystemType(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-是否系统类型不能为空",false);
Assert.isNull(omsEvaluationFillRole.getOrderNumber(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-排序不能为空",false);
Assert.isNull(omsEvaluationFillRole.getBatchCode(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（牵头人）-批次标识不能为空",false);
      string = mOmsEvaluationFillRoleService.addEvaFillRole(omsEvaluationFillRole)/*vcase invoke 本地 method 方法调用;*/;
      
      
      string_1 = string;
           }
    
//步骤3: D1-查询角色详情(公共) - queryRoleDetailCom
     QueryRoleDetailComRespDto queryRoleDetailComRespDto_2 = null;
    QueryRoleDetailComReqDto queryRoleDetailComReqDto_1=new QueryRoleDetailComReqDto();
  queryRoleDetailComReqDto_1.setRoleCode("PERSON_LIABLE");//CUSTOM_CONVENTION//sourceId:1238624_1

    /*D1-查询角色详情（责任人）[2747]   */

      queryRoleDetailComRespDto_2 = fwBaseRoleClient.queryRoleDetailCom(queryRoleDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: 3-2-06新增评价填报角色 - addEvaFillRole
     String string_2 = null;
    if(queryRoleDetailComRespDto_2 !=null){
          OmsEvaluationFillRole omsEvaluationFillRole_1=new OmsEvaluationFillRole();
  omsEvaluationFillRole_1.setRoleTypeCode("APPLICANT");//sourceId:1238629_1
omsEvaluationFillRole_1.setIsSystemType("TRUE");//sourceId:1238631_1
omsEvaluationFillRole_1.setOrderNumber(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1238632_1
if(queryRoleDetailComRespDto_2!=null){
      omsEvaluationFillRole_1.setRoleId(queryRoleDetailComRespDto_2.getRoleId());//SimpleFieldAssign//sourceId:1238635_1
omsEvaluationFillRole_1.setRoleCode(queryRoleDetailComRespDto_2.getRoleCode());//SimpleFieldAssign//sourceId:1238628_1
omsEvaluationFillRole_1.setRoleName(queryRoleDetailComRespDto_2.getRoleName());//SimpleFieldAssign//sourceId:1238636_1
    }
if(reqDto!=null){
      omsEvaluationFillRole_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238630_1
omsEvaluationFillRole_1.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1238637_1
omsEvaluationFillRole_1.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1238633_1
    }

    /*3-2-06新增填报角色（责任人）[2449]   */
    Assert.isNull(omsEvaluationFillRole_1.getRoleId(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色ID不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getRoleCode(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色标识不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getRoleName(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-普通角色名称不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getRoleTypeCode(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-评价填报角色类型编码不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getEvaluationTemplateId(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-评价模板ID不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getIsSystemType(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-是否系统类型不能为空",false);
Assert.isNull(omsEvaluationFillRole_1.getOrderNumber(),"D3-2新增评价填报角色(公共)-3-2-06新增填报角色（责任人）-排序不能为空",false);
      string_2 = mOmsEvaluationFillRoleService.addEvaFillRole(omsEvaluationFillRole_1)/*vcase invoke 本地 method 方法调用;*/;



           }

//步骤5: D2-3查配置项匹配答案列表(公共)（跨服务） - queryConfItemMatchAnswerListCom
     QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
    QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto.setConfItemCode("EVA_ROLE_SET");//CUSTOM_CONVENTION//sourceId:376018_1
queryConfItemMatchAnswerListComReqDto.setIsPlatData("TRUE");//sourceId:376021_1
if(reqDto!=null){
      queryConfItemMatchAnswerListComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:952858_1
    }
  
    /*D2-3查评价角色配置答案[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfSchemeId(),"D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(),"D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(),"D3-2新增评价填报角色(公共)-D2-3查评价角色配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
    
//步骤6: D1-2查询角色列表ByCodes(公共) - batchQueryRoleListByCodesCom
     BatchQueryRoleListByCodesComRespDto batchQueryRoleListByCodesComRespDto = null;
    if(queryConfItemMatchAnswerListComRespDto !=null){
          BatchQueryRoleListByCodesComReqDto batchQueryRoleListByCodesComReqDto=new BatchQueryRoleListByCodesComReqDto();
  if(queryConfItemMatchAnswerListComRespDto!= null&&  queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() !=null&& !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())){
      batchQueryRoleListByCodesComReqDto.setRoleCodeList(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item->item.getEndValue())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:376029_1
    }
  
    /*D1-2查询角色列表ByCodes(公共)[3223]   */
    
      batchQueryRoleListByCodesComRespDto = fwBaseRoleClient.batchQueryRoleListByCodesCom(batchQueryRoleListByCodesComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
    
//步骤7: 3-2-06批量增评价填报角色 - batchAddEvaFillRole
     boolean bOOLEAN ;
    if(batchQueryRoleListByCodesComRespDto !=null){
          List<OmsEvaluationFillRole> listOmsEvaluationFillRole=new ArrayList<>();
  if(batchQueryRoleListByCodesComRespDto!= null&&  batchQueryRoleListByCodesComRespDto.getRoleList() !=null&& !CollectionUtil.isEmpty(batchQueryRoleListByCodesComRespDto.getRoleList())){
      listOmsEvaluationFillRole = //objList-to-objLists
        batchQueryRoleListByCodesComRespDto.getRoleList().stream().map(item -> {
      OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
      elm.setRoleTypeCode("VALUATOR");//sourceId:106792_2
elm.setIsSystemType("TRUE");//sourceId:106794_2
elm.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:106795_2
if(item!=null){
      elm.setRoleId(item.getRoleId());//SimpleFieldAssign//sourceId:106797_2
elm.setRoleCode(item.getRoleCode());//SimpleFieldAssign//sourceId:106791_2
elm.setRoleName(item.getRoleName());//SimpleFieldAssign//sourceId:106798_2
    }
if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:106793_2
elm.setBatchCode(reqDto.getBatchCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:106796_2
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:376025_1
    }
  
    /*3-2-06批量增评价角色[3217]   */
    
      bOOLEAN = mOmsEvaluationFillRoleService.batchAddEvaFillRole(listOmsEvaluationFillRole)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
AddEvaFillRoleComRespDto retData = new AddEvaFillRoleComRespDto();
  if(string_1!=null){
      retData.setEvaluationFillRoleId(string_1);//SimpleFieldAssign//sourceId:376038_1
    }
  

  
  
return retData;
  }
/**
   * D3-2执行删除模板克隆答案等相关(公共)[4845]
   * gen by moon at 5/14/2023, 2:57:47 AM
   */
  @Trace(operationName = "D3-2执行删除模板克隆答案等相关(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTempCloneResultEtcComRespDto implementTempCloneResultEtcCom(ImplementTempCloneResultEtcComReqDto reqDto){
    
      
      //virtualUsage M3异步开始（特殊方法）  19548
      //ModelCode: asynchronizationStart
Callable<String> call = new Callable<String>() {

    @Override
    public String call() throws Exception {
        //执行方法
//virtualUsage 3-2-09执行悬停查调度任务（悬停）  39673
      OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
    ImplementSpinLockCheckTimingTaskReq implementSpinLockCheckTimingTaskReq=new ImplementSpinLockCheckTimingTaskReq();
  if(reqDto!=null){
      implementSpinLockCheckTimingTaskReq.setTimingTaskDispatchId(reqDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:890349_1_39673
implementSpinLockCheckTimingTaskReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:890357_1_39673
    }

    /*3-2-09执行悬停查调度任务（悬停）[4310]   */
    Assert.isNull(implementSpinLockCheckTimingTaskReq.getTimingTaskDispatchId(),"D3-2执行删除模板克隆答案等相关(公共)-3-2-09执行悬停查调度任务（悬停）-定时任务调度记录ID不能为空",false);
Assert.isNull(implementSpinLockCheckTimingTaskReq.getSpaceId(),"D3-2执行删除模板克隆答案等相关(公共)-3-2-09执行悬停查调度任务（悬停）-创建于空间ID不能为空",false);
      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.implementSpinLockCheckTimingTask(implementSpinLockCheckTimingTaskReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetTimingTaskDispatch!= null&& omsTargetTimingTaskDispatch.getTimingTaskDispatchId() == null ||omsTargetTimingTaskDispatch!= null&&  omsTargetTimingTaskDispatch.getIsComplete() !=null && omsTargetTimingTaskDispatch.getIsComplete().equals("TRUE"))) {
        //if((3-2-09执行悬停查调度任务（悬停）.定时任务调度记录ID 值等于空  or 3-2-09执行悬停查调度任务（悬停）.是否执行完成 等于 是))  39685

//异常结束 39687
      throw new BizException("C00028","对不起，没有数据！！",false);
      }
//virtualUsage M3业务应用公共字段推送内存  39689
      //ModelCode: publicFieldCache
        ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
    if(omsTargetTimingTaskDispatch !=null){
          ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq=new ImplementBizPublicFieldPushMemoryReqDto();
  if(omsTargetTimingTaskDispatch!=null){
      publicFieldCacheReq.setCreateInductionId(omsTargetTimingTaskDispatch.getCreateInductionId());//SimpleFieldAssign//sourceId:890375_1_39689
publicFieldCacheReq.setSpaceId(omsTargetTimingTaskDispatch.getSpaceId());//SimpleFieldAssign//sourceId:890376_1_39689
publicFieldCacheReq.setAppId(omsTargetTimingTaskDispatch.getAppId());//SimpleFieldAssign//sourceId:890377_1_39689
    }

    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
    Assert.isNull(publicFieldCacheReq.getCreateInductionId(),"D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空",false);
Assert.isNull(publicFieldCacheReq.getSpaceId(),"D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空",false);
Assert.isNull(publicFieldCacheReq.getAppId(),"D3-2执行删除模板克隆答案等相关(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空",false);
      publicFieldCacheRes = nbEvaTheme.implementBizPublicFieldPushMemory(publicFieldCacheReq);



           }
//virtualUsage D2-3更新删除涉及授权方案信息(公共)  39680
      RefreshDelInvolveAuthorizationSchInfoComRespDto refreshDelInvolveAuthorizationSchInfoComRespDto = null;
    if(omsTargetTimingTaskDispatch !=null){
          RefreshDelInvolveAuthorizationSchInfoComReqDto refreshDelInvolveAuthorizationSchInfoComReqDto=new RefreshDelInvolveAuthorizationSchInfoComReqDto();
  if(omsTargetTimingTaskDispatch!=null){
refreshDelInvolveAuthorizationSchInfoComReqDto.setConfSchemeId(omsTargetTimingTaskDispatch.getObjectId());//SimpleFieldAssign//sourceId:890400_1_39680
refreshDelInvolveAuthorizationSchInfoComReqDto.setEvaluationTemplateId(omsTargetTimingTaskDispatch.getThemeContentId());//SimpleFieldAssign//sourceId:890399_1_39680
    }

    /*D2-3更新删除涉及授权方案信息(公共)[4837]   */
Assert.isNull(refreshDelInvolveAuthorizationSchInfoComReqDto.getConfSchemeId(),"D3-2执行删除模板克隆答案等相关(公共)-D2-3更新删除涉及授权方案信息(公共)-配置方案ID 不能为空",false);
Assert.isNull(refreshDelInvolveAuthorizationSchInfoComReqDto.getEvaluationTemplateId(),"D3-2执行删除模板克隆答案等相关(公共)-D2-3更新删除涉及授权方案信息(公共)-冗余评价模板ID不能为空",false);
      refreshDelInvolveAuthorizationSchInfoComRespDto = fwCompSchemeOpenRecordClient.refreshDelInvolveAuthorizationSchInfoCom(refreshDelInvolveAuthorizationSchInfoComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D2更新评价主题开通记录  39952
      ImplementUpdateSchOpenRecordComRespDto implementUpdateSchOpenRecordComRespDto = null;
    if(omsTargetTimingTaskDispatch !=null){
          ImplementUpdateSchOpenRecordComReqDto implementUpdateSchOpenRecordComReqDto=new ImplementUpdateSchOpenRecordComReqDto();
implementUpdateSchOpenRecordComReqDto.setCustomField1("DEL");//CUSTOM_CONVENTION//sourceId:896045_1_39952
if(omsTargetTimingTaskDispatch!=null){
      implementUpdateSchOpenRecordComReqDto.setConfSchemeId(omsTargetTimingTaskDispatch.getAddRuleInfoId());//SimpleFieldAssign//sourceId:896046_1_39952
implementUpdateSchOpenRecordComReqDto.setTenantSpaceId(omsTargetTimingTaskDispatch.getSpaceId());//SimpleFieldAssign//sourceId:896047_1_39952
    }

    /*D2更新评价主题开通记录[6468]   */
    Assert.isNull(implementUpdateSchOpenRecordComReqDto.getConfSchemeId(),"D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-配置方案ID 不能为空",false);
Assert.isNull(implementUpdateSchOpenRecordComReqDto.getTenantSpaceId(),"D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-租户空间ID不能为空",false);
Assert.isNull(implementUpdateSchOpenRecordComReqDto.getCustomField1(),"D3-2执行删除模板克隆答案等相关(公共)-D2更新评价主题开通记录-更新操作场景不能为空",false);
      implementUpdateSchOpenRecordComRespDto = fwCompSchemeOpenRecordClient.implementUpdateSchOpenRecordCom(implementUpdateSchOpenRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage 3-2-09查询定时任务调度详情  26599
      OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch_2 = null;
    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
  if(reqDto!=null){
      queryTimerTaskPlanDetailReq.setTimingTaskDispatchId(reqDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:586523_1_26599
    }
  
    /*3-2-09查询定时任务调度详情[3187]   */
    Assert.isNull(queryTimerTaskPlanDetailReq.getTimingTaskDispatchId(),"D3-2执行删除模板克隆答案等相关(公共)-3-2-09查询定时任务调度详情-定时任务调度记录ID不能为空",false);
      omsTargetTimingTaskDispatch_2 = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((omsTargetTimingTaskDispatch_2!= null&&  omsTargetTimingTaskDispatch_2.getIsComplete() !=null && omsTargetTimingTaskDispatch_2.getIsComplete().equals("FALSE"))) {
        //if(3-2-09查询定时任务调度详情.是否执行完成 等于 否)  19551
  
boolean bOOLEAN ;
    if(omsTargetTimingTaskDispatch_2 !=null){
    String string=new String();
  if(omsTargetTimingTaskDispatch_2!=null){
      string=omsTargetTimingTaskDispatch_2.getTimingTaskDispatchId();;//SimpleFieldAssign//sourceId:378811_1_26600
    }
  
    /*3-2-09删除定时任务调度[3279]   */
    Assert.isNull(string,"D3-2执行删除模板克隆答案等相关(公共)-3-2-09删除定时任务调度-定时任务调度记录ID不能为空",false);
      bOOLEAN = mOmsTargetTimingTaskDispatchService.deleteTimerTaskPlan(string)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    }
      }
else{
       //else  26602

//异常结束 26603
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
//virtualUsage M3异步结束（特殊方法）  19550
      //ModelCode: asynchronizationEnd
        return "";
    }
};
CommonFunctionHelper.asynExcute(call);
ImplementTempCloneResultEtcComRespDto retData = new ImplementTempCloneResultEtcComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-2检查是否参与评价工作(公共)[3228]
   * gen by moon at 12/31/2022, 5:30:17 PM
   */
  @Trace(operationName = "D3-2检查是否参与评价工作(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CheckIsOpenEvaComRespDto checkIsOpenEvaCom(CheckIsOpenEvaComReqDto reqDto){


      AddOutputParametersRespDto receptionServiceRes_1 =null;
ImplementOutputParametersRespDto receptionServiceRes_3 =null;
//virtualUsage D3执行内容类型互转表类型(公共)  26071
      ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:559193_1_26071
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3-2检查是否参与评价工作(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto);



//virtualUsage D3判断目标内容是否开启主观评分(公共)  25133
      JudgeTargetContIsOpenCustomReportComRespDto judgeTargetContIsOpenCustomReportComRespDto = null;
    JudgeTargetContIsOpenCustomReportComReqDto judgeTargetContIsOpenCustomReportComReqDto=new JudgeTargetContIsOpenCustomReportComReqDto();
if(reqDto!=null){
      judgeTargetContIsOpenCustomReportComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:514393_1_25133
judgeTargetContIsOpenCustomReportComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:514392_1_25133
judgeTargetContIsOpenCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:514394_1_25133
    }

    /*D3判断目标内容是否开启主观评分(公共)[5008]   */
    Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getTargetCycleContentTypeCode(),"D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getTargetCycleContentId(),"D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-关联目标内容ID不能为空",false);
Assert.isNull(judgeTargetContIsOpenCustomReportComReqDto.getEvaluationTemplateId(),"D3-2检查是否参与评价工作(公共)-D3判断目标内容是否开启主观评分(公共)-冗余评价模板ID不能为空",false);
      judgeTargetContIsOpenCustomReportComRespDto = indexSystemService.judgeTargetContIsOpenCustomReportCom(judgeTargetContIsOpenCustomReportComReqDto);



//virtualUsage 3-6-02查虚拟组织成员列表  6666
      List<OmsVirtualOrgMember> listOmsVirtualOrgMember =new ArrayList<>();
    if(implementContentTypeChangeTableTypeComRespDto !=null){
    QueryVirtualOrgMemberListReq queryVirtualOrgMemberListReq=new QueryVirtualOrgMemberListReq();
  queryVirtualOrgMemberListReq.setVirtualOrgInductionRecordId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:122747_1_6666
queryVirtualOrgMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:122742_1_6666
if(reqDto!=null){
      queryVirtualOrgMemberListReq.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:122750_1_6666
    }
if(implementContentTypeChangeTableTypeComRespDto!=null){
      queryVirtualOrgMemberListReq.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:122741_1_6666
    }

    /*3-6-02查虚拟组织成员列表[2201]   */
    Assert.isNull(queryVirtualOrgMemberListReq.getEntityId(),"D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getTableTypeCode(),"D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getVirtualOrgInductionRecordId(),"D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-虚拟组织成员就职记录ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberListReq.getSubjectLifeCycle(),"D3-2检查是否参与评价工作(公共)-3-6-02查虚拟组织成员列表-主体生命周期不能为空",false);
      listOmsVirtualOrgMember = mOmsVirtualOrgMemberService.queryVirtualOrgMemberList(queryVirtualOrgMemberListReq);



           }
//virtualUsage 3-2-06查询评价填报角色列表ByCodes  6667
      List<OmsEvaluationFillRole> listOmsEvaluationFillRole =new ArrayList<>();
    if(listOmsVirtualOrgMember !=null&& !CollectionUtil.isEmpty(listOmsVirtualOrgMember)&& listOmsVirtualOrgMember.size()>0 ){
          BatchQueryEvaFillRoleListByCodesReq batchQueryEvaFillRoleListByCodesReq=new BatchQueryEvaFillRoleListByCodesReq();
  batchQueryEvaFillRoleListByCodesReq.setEvaFillRoleList(listOmsVirtualOrgMember.stream().map(item->item.getRoleCode())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:122734_1_6667
if(reqDto!=null){
      batchQueryEvaFillRoleListByCodesReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:122737_1_6667
      batchQueryEvaFillRoleListByCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:122735_1_6667
    }

    /*3-2-06查询评价填报角色列表ByCodes[3230]   */
    Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getRoleTypeCode(),"D3-2检查是否参与评价工作(公共)-3-2-06查询评价填报角色列表ByCodes-评价填报角色类型编码不能为空",false);
    Assert.isNull(batchQueryEvaFillRoleListByCodesReq.getEvaluationTemplateId(),"D3-2检查是否参与评价工作(公共)-3-2-06查询评价填报角色列表ByCodes-评价模板ID不能为空",false);
      listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.batchQueryEvaFillRoleListByCodes(batchQueryEvaFillRoleListByCodesReq);



           }
if((judgeTargetContIsOpenCustomReportComRespDto!= null&&  judgeTargetContIsOpenCustomReportComRespDto.getIsSubjectiveScoring() !=null && judgeTargetContIsOpenCustomReportComRespDto.getIsSubjectiveScoring().equals("TRUE")&&listOmsEvaluationFillRole!= null&&  listOmsEvaluationFillRole !=null && listOmsEvaluationFillRole.size()>0)) {
        //if((D3判断目标内容是否开启主观评分(公共).是否开启主观评分 等于 是 and 3-2-06查询评价填报角色列表ByCodes.评价填报角色列表数据集条数 大于 0))  6668

//ModelCode: receptionService
        AddOutputParametersRespDto receptionServiceRes = null;
    AddOutputParametersReqDto receptionServiceReq=new AddOutputParametersReqDto();
  receptionServiceReq.setIsOpenEvaWork("TRUE");//sourceId:312650_1_6669

    /*模板开启评价工作[2888] 第一个分支返回：TRUE，第二个分支返回：FALSE 用于特殊方法接收上游入参。 */

      receptionServiceRes = nbEvaTheme.addOutputParameters(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15911

      }
else{
       //else  6670

//ModelCode: receptionService
        ImplementOutputParametersRespDto receptionServiceRes_2 = null;
    ImplementOutputParametersReqDto receptionServiceReq_1=new ImplementOutputParametersReqDto();
  receptionServiceReq_1.setIsOpenEvaWork("FALSE");//sourceId:312658_1_15910

    /*模板未开启评价工作[2888]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbEvaTheme.implementOutputParameters(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
//processBranchName:正常结束 ,processBranchId:15912

    }
CheckIsOpenEvaComRespDto retData = new CheckIsOpenEvaComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsOpenEvaWork(receptionServiceRes_1.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
    }
if(receptionServiceRes_3!=null){
      retData.setIsOpenEvaWork(receptionServiceRes_3.getIsOpenEvaWork());//SimpleFieldAssign//sourceId:123055_1
    }




return retData;
  }
/**
   * D3-2查询评价填报角色详情(公共)[3333]
   * gen by moon at 12/16/2022, 9:08:00 PM
   */
  @Trace(operationName = "D3-2查询评价填报角色详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaFillRoleDetailComRespDto queryEvaFillRoleDetailCom(QueryEvaFillRoleDetailComReqDto reqDto){


      OmsEvaluationFillRole omsEvaluationFillRole_1 =null;
//步骤0: 3-2-06查评价填报角色详情 - queryEvaFillRoleDetail
     OmsEvaluationFillRole omsEvaluationFillRole = null;
    QueryEvaFillRoleDetailReq queryEvaFillRoleDetailReq=new QueryEvaFillRoleDetailReq();
  if(reqDto!=null){
      queryEvaFillRoleDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:131347_1
queryEvaFillRoleDetailReq.setRoleTypeCode(reqDto.getRoleTypeCode());//SimpleFieldAssign//sourceId:131348_1
queryEvaFillRoleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:131349_1
queryEvaFillRoleDetailReq.setIsSystemType(reqDto.getIsSystemType());//SimpleFieldAssign//sourceId:131350_1
queryEvaFillRoleDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:131351_1
    }

    /*3-2-06查评价填报角色详情[2380]   */

      omsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleDetail(queryEvaFillRoleDetailReq);


      omsEvaluationFillRole_1 = omsEvaluationFillRole;

QueryEvaFillRoleDetailComRespDto retData = new QueryEvaFillRoleDetailComRespDto();
  if(omsEvaluationFillRole_1!=null){
      retData.setEvaluationFillRoleId(omsEvaluationFillRole_1.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:131383_1
retData.setRoleId(omsEvaluationFillRole_1.getRoleId());//SimpleFieldAssign//sourceId:520844_1
retData.setRoleCode(omsEvaluationFillRole_1.getRoleCode());//SimpleFieldAssign//sourceId:520847_1
retData.setRoleName(omsEvaluationFillRole_1.getRoleName());//SimpleFieldAssign//sourceId:520850_1
    }




return retData;
  }
/**
   * D3执行高层人工设置完成[5542]
   * gen by moon at 11/24/2023, 10:36:01 PM
   */
  @Trace(operationName = "D3执行高层人工设置完成")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMidManualSetCompletRespDto implementMidManualSetComplet(ImplementMidManualSetCompletReqDto reqDto){


      //virtualUsage 3-3-05查询是否有下发指标  25871
      List<OmsTargetObjectivePlanExtend> listOmsTargetObjectivePlanExtend =new ArrayList<>();
    QueryTargetObjPlanExListReq queryTargetObjPlanExListReq=new QueryTargetObjPlanExListReq();
  queryTargetObjPlanExListReq.setIsFirstObjective("TRUE");//sourceId:551759_1_25871
queryTargetObjPlanExListReq.setIsArchive("FALSE");//sourceId:551761_1_25871
if(reqDto!=null){
      queryTargetObjPlanExListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551755_1_25871
    }

    /*3-3-05查询是否有下发指标[3650]   */
    Assert.isNull(queryTargetObjPlanExListReq.getIsFirstObjective(),"D3执行高层人工设置完成-3-3-05查询是否有下发指标-是否目标下发不能为空",false);
Assert.isNull(queryTargetObjPlanExListReq.getEvaluationTemplateId(),"D3执行高层人工设置完成-3-3-05查询是否有下发指标-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjPlanExListReq.getIsArchive(),"D3执行高层人工设置完成-3-3-05查询是否有下发指标-是否存档不能为空",false);
      listOmsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExList(queryTargetObjPlanExListReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-11-01查评价模板级别目标的完成状态  25878
      OmsAssistNodeStatus omsAssistNodeStatus = null;
    QueryAssistNodeStatusDetailReq queryAssistNodeStatusDetailReq=new QueryAssistNodeStatusDetailReq();
  queryAssistNodeStatusDetailReq.setAssistNodeTypeCode("OMS_TARGET");//sourceId:551684_1_25878
queryAssistNodeStatusDetailReq.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:551703_1_25878
if(reqDto!=null){
      queryAssistNodeStatusDetailReq.setAssistNodeTypeObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:551685_1_25878
queryAssistNodeStatusDetailReq.setObjectId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551704_1_25878
    }

    /*3-11-01查评价模板级别目标的完成状态[317]   */
    Assert.isNull(queryAssistNodeStatusDetailReq.getAssistNodeTypeObjectId(),"D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-节点内容对象实例ID不能为空",false);
Assert.isNull(queryAssistNodeStatusDetailReq.getAssistNodeTypeCode(),"D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-节点内容对象类型编码不能为空",false);
Assert.isNull(queryAssistNodeStatusDetailReq.getObjectTypeCode(),"D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-归属对象类型编码不能为空",false);
Assert.isNull(queryAssistNodeStatusDetailReq.getObjectId(),"D3执行高层人工设置完成-3-11-01查评价模板级别目标的完成状态-归属对象内容ID不能为空",false);
      omsAssistNodeStatus = mOmsAssistNodeStatusService.queryAssistNodeStatusDetail(queryAssistNodeStatusDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsAssistNodeStatus== null||  omsAssistNodeStatus.getIsComplete() ==null,"找不到数据，系统异常",false);


//virtualUsage 3-3-09-03查询评价模板批次设置详情  25879
      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq=new QueryPlanEvaBatchSetDetailReq();
  queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:551646_1_25879
queryPlanEvaBatchSetDetailReq.setCurrentManageObjectType("TOP");//sourceId:551656_1_25879
queryPlanEvaBatchSetDetailReq.setManageLockStatus("UNLOCK");//sourceId:551762_1_25879
if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551645_1_25879
    }

    /*3-3-09-03查询评价模板批次设置详情[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(),"D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(),"D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-批次设置对象类型不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getCurrentManageObjectType(),"D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-当前管理对象类型不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getManageLockStatus(),"D3执行高层人工设置完成-3-3-09-03查询评价模板批次设置详情-管理锁定状态不能为空",false);
      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaBatchRelatedSet== null||  omsEvaBatchRelatedSet.getBatchRelatedSetId() ==null||omsEvaBatchRelatedSet== null||  omsEvaBatchRelatedSet.getSetCompleteStatus() ==null,"找不到数据，系统异常",false);


if((listOmsTargetObjectivePlanExtend!= null&&  listOmsTargetObjectivePlanExtend !=null && listOmsTargetObjectivePlanExtend.size()==0&&reqDto!= null&&  reqDto.getSetCompleteStatus() !=null && reqDto.getSetCompleteStatus().equals("TRUE"))) {
        //if((3-3-05查询是否有下发指标.指标扩展规划设置列表数据集条数 等于 0 and D3执行高层人工设置完成.设置完成状态 等于 是))  25880

List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    QueryTimerTaskPlanListReq queryTimerTaskPlanListReq=new QueryTimerTaskPlanListReq();
  queryTimerTaskPlanListReq.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:551730_1_25882
queryTimerTaskPlanListReq.setIsAppointSimpleMq("TRUE");//sourceId:551732_1_25882
queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:551736_1_25882
queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:551733_1_25882
if(reqDto!=null){
      queryTimerTaskPlanListReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:551731_1_25882
    }

    /*3-2-09查询指标下发前MQ队列定时任务调度列表[3261]   */
    Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(),"D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-主题内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getThemeContentTypeCode(),"D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-主题内容类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getIsAppointSimpleMq(),"D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-是否固化消息队列不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(),"D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-是否执行完成不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(),"D3执行高层人工设置完成-3-2-09查询指标下发前MQ队列定时任务调度列表-创建于空间ID不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsAssistNodeStatus!= null&&  omsAssistNodeStatus.getIsComplete() !=null && omsAssistNodeStatus.getIsComplete().equals("TRUE")&&omsEvaBatchRelatedSet!= null&&  omsEvaBatchRelatedSet.getSetCompleteStatus() !=null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("FALSE")&&listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()==0)) {
        //if((3-11-01查评价模板级别目标的完成状态.是否已完成 等于 是 and 3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 否 and 3-2-09查询指标下发前MQ队列定时任务调度列表.定时任务调度列表数据集条数 等于 0))  25885

boolean bOOLEAN ;
    if(omsEvaBatchRelatedSet !=null){
          OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_2=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25886
omsEvaBatchRelatedSet_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25886
if(omsEvaBatchRelatedSet!=null){
      omsEvaBatchRelatedSet_2.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25886
    }
if(reqDto!=null){
      omsEvaBatchRelatedSet_2.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25886
    }

    /*3-3-09-03修改评价模板批次设置[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet_2.getBatchRelatedSetId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_2.getSetCompleteStatus(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_2.getOperationInductionId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_2.getOperateTime(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空",false);
      bOOLEAN = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()>0)){
       //elseif(3-2-09查询指标下发前MQ队列定时任务调度列表.定时任务调度列表数据集条数 大于 0)  25888

//异常结束 25889
      throw new BizException("330000166","对不起，当前规划还有设置在自动执行，请耐心等待~。",false);
    }
      }
else if((listOmsTargetObjectivePlanExtend!= null&&  listOmsTargetObjectivePlanExtend !=null && listOmsTargetObjectivePlanExtend.size()>0&&reqDto!= null&&  reqDto.getSetCompleteStatus() !=null && reqDto.getSetCompleteStatus().equals("TRUE"))){
       //elseif((3-3-05查询是否有下发指标.指标扩展规划设置列表数据集条数 大于 0 and D3执行高层人工设置完成.设置完成状态 等于 是))  25881

if((omsAssistNodeStatus!= null&&  omsAssistNodeStatus.getIsComplete() !=null && omsAssistNodeStatus.getIsComplete().equals("TRUE")&&omsEvaBatchRelatedSet!= null&&  omsEvaBatchRelatedSet.getSetCompleteStatus() !=null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("FALSE"))) {
        //if((3-11-01查评价模板级别目标的完成状态.是否已完成 等于 是 and 3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 否))  25884

boolean bOOLEAN_1 ;
    if(omsEvaBatchRelatedSet !=null){
          OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_3=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet_3.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25887
omsEvaBatchRelatedSet_3.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25887
if(omsEvaBatchRelatedSet!=null){
      omsEvaBatchRelatedSet_3.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25887
    }
if(reqDto!=null){
      omsEvaBatchRelatedSet_3.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25887
    }

    /*3-3-09-03修改评价模板批次设置[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet_3.getBatchRelatedSetId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_3.getSetCompleteStatus(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_3.getOperationInductionId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_3.getOperateTime(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空",false);
      bOOLEAN_1 = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_3)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
    }
else if((omsEvaBatchRelatedSet!= null&&  omsEvaBatchRelatedSet.getSetCompleteStatus() !=null && omsEvaBatchRelatedSet.getSetCompleteStatus().equals("TRUE")&&reqDto!= null&&  reqDto.getSetCompleteStatus() !=null && reqDto.getSetCompleteStatus().equals("FALSE"))){
       //elseif((3-3-09-03查询评价模板批次设置详情.设置完成状态 等于 是 and D3执行高层人工设置完成.设置完成状态 等于 否))  25890

boolean bOOLEAN_2 ;
    if(omsEvaBatchRelatedSet !=null){
          OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_4=new OmsEvaBatchRelatedSet();
  omsEvaBatchRelatedSet_4.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:551764_1_25891
omsEvaBatchRelatedSet_4.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:551765_1_25891
if(omsEvaBatchRelatedSet!=null){
      omsEvaBatchRelatedSet_4.setBatchRelatedSetId(omsEvaBatchRelatedSet.getBatchRelatedSetId());//SimpleFieldAssign//sourceId:551763_1_25891
    }
if(reqDto!=null){
      omsEvaBatchRelatedSet_4.setSetCompleteStatus(reqDto.getSetCompleteStatus());//SimpleFieldAssign//sourceId:551767_1_25891
    }

    /*3-3-09-03修改评价模板批次设置[3034]   */
    Assert.isNull(omsEvaBatchRelatedSet_4.getBatchRelatedSetId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-批次相关设置ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_4.getSetCompleteStatus(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-设置完成状态不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_4.getOperationInductionId(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaBatchRelatedSet_4.getOperateTime(),"D3执行高层人工设置完成-3-3-09-03修改评价模板批次设置-操作时间不能为空",false);
      bOOLEAN_2 = mOmsEvaBatchRelatedSetService.updatePlanEvaBatchSet(omsEvaBatchRelatedSet_4)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsAssistNodeStatus!= null&&  omsAssistNodeStatus.getIsComplete() !=null && omsAssistNodeStatus.getIsComplete().equals("FALSE"))) {
        //if(3-11-01查评价模板级别目标的完成状态.是否已完成 等于 否)  54596

boolean bOOLEAN_3 ;
    if(omsAssistNodeStatus !=null){
          OmsAssistNodeStatus omsAssistNodeStatus_2=new OmsAssistNodeStatus();
  omsAssistNodeStatus_2.setIsComplete("TRUE");//sourceId:1350854_1_54597
omsAssistNodeStatus_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1350855_1_54597
omsAssistNodeStatus_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1350856_1_54597
if(omsAssistNodeStatus!=null){
      omsAssistNodeStatus_2.setAssistNodeStatusId(omsAssistNodeStatus.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:1350853_1_54597
    }

    /*3-11-01修改内容节点状态[315]   */
    Assert.isNull(omsAssistNodeStatus_2.getAssistNodeStatusId(),"D3执行高层人工设置完成-3-11-01修改内容节点状态-内容节点状态ID不能为空",false);
Assert.isNull(omsAssistNodeStatus_2.getIsComplete(),"D3执行高层人工设置完成-3-11-01修改内容节点状态-是否已完成不能为空",false);
Assert.isNull(omsAssistNodeStatus_2.getOperationInductionId(),"D3执行高层人工设置完成-3-11-01修改内容节点状态-操作人就职记录ID不能为空",false);
Assert.isNull(omsAssistNodeStatus_2.getOperateTime(),"D3执行高层人工设置完成-3-11-01修改内容节点状态-操作时间不能为空",false);
      bOOLEAN_3 = mOmsAssistNodeStatusService.updateAssistNodeStatus(omsAssistNodeStatus_2)/*vcase invoke 本地 method 方法调用;*/;



           }
           }
    }
ImplementMidManualSetCompletRespDto retData = new ImplementMidManualSetCompletRespDto();





return retData;
  }
/**
   * D3查询评价主题列表(公共)[5717]
   * gen by moon at 1/27/2023, 8:24:44 PM
   */
  @Trace(operationName = "D3查询评价主题列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaThemeListComRespDto queryEvaThemeListCom(QueryEvaThemeListComReqDto reqDto){


      List<OmsEvaluationSubject> listOmsEvaluationSubject_1 =new ArrayList<>();
      //步骤0: 3-2-01查评价主题列表 - queryEvaThemeList
     List<OmsEvaluationSubject> listOmsEvaluationSubject =new ArrayList<>();
    QueryEvaThemeListReq queryEvaThemeListReq=new QueryEvaThemeListReq();
  queryEvaThemeListReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:613099_1
if(reqDto!=null){
      queryEvaThemeListReq.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:613110_1
queryEvaThemeListReq.setConfSchemeCode(reqDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:613111_1
queryEvaThemeListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:613100_1
    }

    /*3-2-01查评价主题列表[2278]   */
    Assert.isNull(queryEvaThemeListReq.getSubjectLifeCycle(),"D3查询评价主题列表(公共)-3-2-01查评价主题列表-主体生命周期不能为空",false);
Assert.isNull(queryEvaThemeListReq.getAscriptionSpaceId(),"D3查询评价主题列表(公共)-3-2-01查评价主题列表-归属空间ID不能为空",false);
      listOmsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeList(queryEvaThemeListReq);


      listOmsEvaluationSubject_1 = listOmsEvaluationSubject;

QueryEvaThemeListComRespDto retData = new QueryEvaThemeListComRespDto();
  retData.setEvalThemeList(listOmsEvaluationSubject_1.stream().map(item->item.getEvaluationSubjectId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:637665_1




return retData;
  }
/**
   * D3查询评价模板当前特权管理状态[5856]
   * gen by moon at 2/6/2023, 7:27:59 PM
   */
  @Trace(operationName = "D3查询评价模板当前特权管理状态")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTempPresentIsSuperMgtStateDetailRespDto queryEvaTempPresentIsSuperMgtStateDetail(QueryEvaTempPresentIsSuperMgtStateDetailReqDto reqDto){


      ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("TOP"))) {
        //if(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 高层)  28990

OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq=new QueryPlanEvaBatchSetDetailReq();
  queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:654429_1_28994
if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:654428_1_28994
    }

    /*3-3-09-03查询高层评价模板批次设置[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(),"D3查询评价模板当前特权管理状态-3-3-09-03查询高层评价模板批次设置-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(),"D3查询评价模板当前特权管理状态-3-3-09-03查询高层评价模板批次设置-批次设置对象类型不能为空",false);
      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq);
      Assert.isTrue(omsEvaBatchRelatedSet== null||  omsEvaBatchRelatedSet.getBatchRelatedSetId() ==null,"找不到数据，系统异常",false);


//ModelCode: receptionService
        ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
    if(omsEvaBatchRelatedSet !=null){
          ImplementAccessParameterBizFieldReqDto receptionServiceReq=new ImplementAccessParameterBizFieldReqDto();
  if(omsEvaBatchRelatedSet!=null){
      receptionServiceReq.setMgtType(omsEvaBatchRelatedSet.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28997
      // receptionServiceReq.setIsSuperMgt(omsEvaBatchRelatedSet.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28997
    }

    /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getMgtType(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空",false);
Assert.isNull(receptionServiceReq.getIsSuperMgt(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空",false);
      receptionServiceRes = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("MID"))){
       //elseif(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 中层)  28991

OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_2 = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq_1=new QueryPlanEvaBatchSetDetailReq();
  queryPlanEvaBatchSetDetailReq_1.setBatchSetObjectType("MID_DIV_MGT");//sourceId:654633_1_28995
if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq_1.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:654632_1_28995
    }

    /*3-3-09-03查询中层评价模板批次设置[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq_1.getBatchSetId(),"D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq_1.getBatchSetObjectType(),"D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象类型不能为空",false);
      omsEvaBatchRelatedSet_2 = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq_1);
      Assert.isTrue(omsEvaBatchRelatedSet_2== null||  omsEvaBatchRelatedSet_2.getBatchRelatedSetId() ==null,"找不到数据，系统异常",false);


//ModelCode: receptionService
        ImplementAccessParameterBizFieldRespDto receptionServiceRes_2 = null;
    if(omsEvaBatchRelatedSet_2 !=null){
          ImplementAccessParameterBizFieldReqDto receptionServiceReq_1=new ImplementAccessParameterBizFieldReqDto();
  if(omsEvaBatchRelatedSet_2!=null){
      receptionServiceReq_1.setMgtType(omsEvaBatchRelatedSet_2.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28998
//receptionServiceReq_1.setIsSuperMgt(omsEvaBatchRelatedSet_2.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28998
    }

    /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getMgtType(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空",false);
Assert.isNull(receptionServiceReq_1.getIsSuperMgt(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空",false);
      receptionServiceRes_2 = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((reqDto!= null&&  reqDto.getBatchOperateScene() !=null && reqDto.getBatchOperateScene().equals("BASIC"))){
       //elseif(D3查询评价模板当前超级管理状态.高/中/基层操作场景 等于 基层)  28992

OmsEvaBatchRelatedSet omsEvaBatchRelatedSet_4 = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq_2=new QueryPlanEvaBatchSetDetailReq();
  queryPlanEvaBatchSetDetailReq_2.setBatchSetObjectType("BASIC_DIV_MGT");//sourceId:655227_1_28999
if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq_2.setBatchSetId(reqDto.getBatchSetId());//SimpleFieldAssign//sourceId:655226_1_28999
    }

    /*3-3-09-03查询中层评价模板批次设置[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq_2.getBatchSetId(),"D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq_2.getBatchSetObjectType(),"D3查询评价模板当前特权管理状态-3-3-09-03查询中层评价模板批次设置-批次设置对象类型不能为空",false);
      omsEvaBatchRelatedSet_4 = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq_2);
      Assert.isTrue(omsEvaBatchRelatedSet_4== null||  omsEvaBatchRelatedSet_4.getBatchRelatedSetId() ==null,"找不到数据，系统异常",false);


//ModelCode: receptionService
        ImplementAccessParameterBizFieldRespDto receptionServiceRes_3 = null;
    if(omsEvaBatchRelatedSet_4 !=null){
          ImplementAccessParameterBizFieldReqDto receptionServiceReq_2=new ImplementAccessParameterBizFieldReqDto();
  if(omsEvaBatchRelatedSet_4!=null){
      receptionServiceReq_2.setMgtType(omsEvaBatchRelatedSet_4.getMgtType());//SimpleFieldAssign//sourceId:655228_1_28996
//receptionServiceReq_2.setIsSuperMgt(omsEvaBatchRelatedSet_4.getIsSuperMgt());//SimpleFieldAssign//sourceId:655220_1_28996
    }

    /*M3接收上文出参参数[5797]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getMgtType(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-管理类型不能为空",false);
Assert.isNull(receptionServiceReq_2.getIsSuperMgt(),"D3查询评价模板当前特权管理状态-M3接收上文出参参数-是否超级管理不能为空",false);
      receptionServiceRes_3 = nbEvaTheme.implementAccessParameterBizField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
QueryEvaTempPresentIsSuperMgtStateDetailRespDto retData = new QueryEvaTempPresentIsSuperMgtStateDetailRespDto();
  if(receptionServiceRes_1!=null){
      retData.setMgtType(receptionServiceRes_1.getMgtType());//SimpleFieldAssign//sourceId:655233_1
retData.setIsSuperMgt(receptionServiceRes_1.getIsSuperMgt());//SimpleFieldAssign//sourceId:655234_1
    }




return retData;
  }
/**
   * D3执行评价模板新增条件判断(公共)[6410]
   * gen by moon at 5/1/2023, 10:17:48 PM
   */
  @Trace(operationName = "D3执行评价模板新增条件判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEvaTempAddTermJudgeComRespDto implementEvaTempAddTermJudgeCom(ImplementEvaTempAddTermJudgeComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_3 =null;
//virtualUsage 3-2-02查主题下正在编辑的评价模板列表  38417
      List<OmsEvaluationTemplate> listOmsEvaluationTemplate =new ArrayList<>();
    QueryEvaTempListReq queryEvaTempListReq=new QueryEvaTempListReq();
  queryEvaTempListReq.setSubjectLifeCycle("EDITING");//sourceId:871923_1_38417
queryEvaTempListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:871921_1_38417
if(reqDto!=null){
      queryEvaTempListReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:871915_1_38417
    }

    /*3-2-02查主题下正在编辑的评价模板列表[2191]   */
    Assert.isNull(queryEvaTempListReq.getEvaluationSubjectId(),"D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-归属评价主题ID不能为空",false);
Assert.isNull(queryEvaTempListReq.getSubjectLifeCycle(),"D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-主体生命周期不能为空",false);
Assert.isNull(queryEvaTempListReq.getSpaceId(),"D3执行评价模板新增条件判断(公共)-3-2-02查主题下正在编辑的评价模板列表-创建于空间ID不能为空",false);
      listOmsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempList(queryEvaTempListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationTemplate!= null&&  listOmsEvaluationTemplate !=null && listOmsEvaluationTemplate.size()>0)) {
        //if(3-2-02查主题下正在编辑的评价模板列表.评价模板列表数据集条数 大于 0)  38418

List<OmsTarget> listOmsTarget =new ArrayList<>();
    if(listOmsEvaluationTemplate !=null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate)&& listOmsEvaluationTemplate.size()>0 ){
          BatchQueryTargetListReq batchQueryTargetListReq=new BatchQueryTargetListReq();
  batchQueryTargetListReq.setDataInitStatus("FALSE");//sourceId:871930_1_38419
batchQueryTargetListReq.setSubjectLifeCycle("EDITING");//sourceId:871929_1_38419
if(listOmsEvaluationTemplate!= null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate)&&  listOmsEvaluationTemplate !=null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate)){
      batchQueryTargetListReq.setTargetList(listOmsEvaluationTemplate.stream().map(item->item.getTargetId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:871925_1_38419
    }

    /*3-3-06批量查未公开的目标列表[2205]   */
    Assert.isNull(batchQueryTargetListReq.getDataInitStatus(),"D3执行评价模板新增条件判断(公共)-3-3-06批量查未公开的目标列表-数据初始化完成状态不能为空",false);
Assert.isNull(batchQueryTargetListReq.getSubjectLifeCycle(),"D3执行评价模板新增条件判断(公共)-3-3-06批量查未公开的目标列表-主体生命周期不能为空",false);
      listOmsTarget = mOmsTargetService.batchQueryTargetList(batchQueryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
if((listOmsTarget!= null&&  listOmsTarget !=null && listOmsTarget.size()==0)) {
        //if(3-3-06批量查未公开的目标列表.目标列表数据集条数 等于 0)  38420

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setCustomField("1");//CUSTOM_CONVENTION//sourceId:872127_1_38421

    /*M3约定为允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3约定为允许新增评价模板-自定义字段不能为空",false);
      receptionServiceRes = nbEvaTheme.implementAcceptField(receptionServiceReq);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setCustomField(receptionServiceRes.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38429
    }

    /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空",false);
      receptionServiceRes_2 = nbEvaTheme.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((listOmsTarget!= null&&  listOmsTarget !=null && listOmsTarget.size()>0)){
       //elseif(3-3-06批量查未公开的目标列表.目标列表数据集条数 大于 0)  38422

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  receptionServiceReq_2.setCustomField("0");//CUSTOM_CONVENTION//sourceId:872586_1_38424

    /*M3约定为不允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3约定为不允许新增评价模板-自定义字段不能为空",false);
      receptionServiceRes_4 = nbEvaTheme.implementAcceptField(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_3=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setCustomField(receptionServiceRes_4.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38428
    }

    /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空",false);
      receptionServiceRes_6 = nbEvaTheme.implementAcceptField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
      }
else if((listOmsEvaluationTemplate!= null&&  listOmsEvaluationTemplate !=null && listOmsEvaluationTemplate.size()==0)){
       //elseif(3-2-02查主题下正在编辑的评价模板列表.评价模板列表数据集条数 等于 0)  38425

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_7 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_4=new ImplementAcceptFieldReqDto();
  receptionServiceReq_4.setCustomField("1");//CUSTOM_CONVENTION//sourceId:872127_1_38426

    /*M3约定为允许新增评价模板[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3约定为允许新增评价模板-自定义字段不能为空",false);
      receptionServiceRes_7 = nbEvaTheme.implementAcceptField(receptionServiceReq_4);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_8 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_5=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes_7!=null){
      receptionServiceReq_5.setCustomField(receptionServiceRes_7.getCustomField());//SimpleFieldAssign//sourceId:872589_1_38427
    }

    /*M3接收上文出参字段值[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getCustomField(),"D3执行评价模板新增条件判断(公共)-M3接收上文出参字段值-自定义字段不能为空",false);
      receptionServiceRes_8 = nbEvaTheme.implementAcceptField(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_8;
    }
ImplementEvaTempAddTermJudgeComRespDto retData = new ImplementEvaTempAddTermJudgeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setIsAddEvaTemp(receptionServiceRes_3.getCustomField());//SimpleFieldAssign//sourceId:872590_1
    }




return retData;
  }
/**
   * D3新增评价模板开通记录[6481]
   * gen by moon at 1/19/2024, 6:29:34 PM
   */
  @Trace(operationName = "D3新增评价模板开通记录")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddEvaTempOpenRecordRespDto addEvaTempOpenRecord(AddEvaTempOpenRecordReqDto reqDto){


      AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto_1 =null;
//virtualUsage 3-2-02查评价模板详情  39928
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setArchivngType("NOT_ARCHIVE");//sourceId:895833_1_39928
queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:895816_1_39928
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:895810_1_39928
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3新增评价模板开通记录-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getArchivngType(),"D3新增评价模板开通记录-3-2-02查评价模板详情-存档类型不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3新增评价模板开通记录-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2-3查评价模板配置方案信息  39939
      QueryConfSchemeDetailComRespDto queryConfSchemeDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
    QueryConfSchemeDetailComReqDto queryConfSchemeDetailComReqDto=new QueryConfSchemeDetailComReqDto();
  queryConfSchemeDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:895953_1_39939
if(omsEvaluationTemplate!=null){
      queryConfSchemeDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:941172_1_39939
    }

    /*D2-3查评价模板配置方案信息[1981]   */
    Assert.isNull(queryConfSchemeDetailComReqDto.getConfSchemeId(),"D3新增评价模板开通记录-D2-3查评价模板配置方案信息-配置方案ID 不能为空",false);
Assert.isNull(queryConfSchemeDetailComReqDto.getSubjectLifeCycle(),"D3新增评价模板开通记录-D2-3查评价模板配置方案信息-生命周期状态不能为空",false);
      queryConfSchemeDetailComRespDto = fwCompConfSchemeClient.queryConfSchemeDetailCom(queryConfSchemeDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage 3-3查目标父周期  39941
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:896029_1_39941
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:896030_1_39941
queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:896031_1_39941
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:896032_1_39941
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:896034_1_39941
queryEvaObjTargetCycleDetailReq.setArchivngType("NOT_ARCHIVE");//sourceId:896035_1_39941
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:896033_1_39941
    }

    /*3-3查目标父周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3新增评价模板开通记录-3-3查目标父周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3新增评价模板开通记录-3-3查目标父周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(),"D3新增评价模板开通记录-3-3查目标父周期-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3新增评价模板开通记录-3-3查目标父周期-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3新增评价模板开通记录-3-3查目标父周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3新增评价模板开通记录-3-3查目标父周期-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getArchivngType(),"D3新增评价模板开通记录-3-3查目标父周期-存档类型不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2新增开通记录并授权(公共)  39922
      AddOpenRecordAuthorizationComRespDto addOpenRecordAuthorizationComRespDto = null;
    if(queryConfSchemeDetailComRespDto !=null&&omsEvaluationObjectTargetCycle !=null&&omsEvaluationTemplate !=null){
          AddOpenRecordAuthorizationComReqDto addOpenRecordAuthorizationComReqDto=new AddOpenRecordAuthorizationComReqDto();
  addOpenRecordAuthorizationComReqDto.setAuthType("FIXED_TIME");//sourceId:895622_1_39922
addOpenRecordAuthorizationComReqDto.setIsMainConfScheme("TRUE");//sourceId:895627_1_39922
addOpenRecordAuthorizationComReqDto.setApplexType("EVA_TEMP");//sourceId:895630_1_39922
addOpenRecordAuthorizationComReqDto.setTenantSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895628_1_39922
addOpenRecordAuthorizationComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:895629_1_39922
if(queryConfSchemeDetailComRespDto!=null){
      addOpenRecordAuthorizationComReqDto.setConfSchemeId(queryConfSchemeDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:895620_1_39922
addOpenRecordAuthorizationComReqDto.setConfSchemeCode(queryConfSchemeDetailComRespDto.getConfSchemeCode());//SimpleFieldAssign//sourceId:895621_1_39922
    }
if(omsEvaluationObjectTargetCycle!=null){
      addOpenRecordAuthorizationComReqDto.setStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:895625_1_39922
addOpenRecordAuthorizationComReqDto.setEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:895626_1_39922
addOpenRecordAuthorizationComReqDto.setApplexName(omsEvaluationObjectTargetCycle.getTargetCycleName());//SimpleFieldAssign//sourceId:915059_1_39922
    }
if(omsEvaluationTemplate!=null){
      addOpenRecordAuthorizationComReqDto.setAuthorizationKeyTypeCode(omsEvaluationTemplate.getTargetPlanTempSubtype());//SimpleFieldAssign//sourceId:932176_1_39922
    }
if(reqDto!=null){
      addOpenRecordAuthorizationComReqDto.setApplexId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:895631_1_39922
    }

    /*D2新增开通记录并授权(公共)[3102]   */
    Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeId(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-配置方案ID 不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getConfSchemeCode(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-配置方案标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthType(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-授权类型不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getStartTime(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开始时间不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getEndTime(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-结束时间不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getIsMainConfScheme(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-是否主配置方案不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexType(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通对象类型编码不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getAuthorizationKeyTypeCode(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通钥匙类型标识不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexId(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-开通对象ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getApplexName(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-冗余开通对象名称不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getTenantSpaceId(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-租户空间ID不能为空",false);
Assert.isNull(addOpenRecordAuthorizationComReqDto.getSubjectLifeCycle(),"D3新增评价模板开通记录-D2新增开通记录并授权(公共)-主体生命周期不能为空",false);
      addOpenRecordAuthorizationComRespDto = fwCompSchemeOpenRecordClient.addOpenRecordAuthorizationCom(addOpenRecordAuthorizationComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      addOpenRecordAuthorizationComRespDto_1 = addOpenRecordAuthorizationComRespDto;
           }
//virtualUsage 3-2-01查评价主题配置方案ID  39932
      OmsEvaluationSubject omsEvaluationSubject = null;
    if(omsEvaluationTemplate !=null){
          QueryEvaThemeDetailReq queryEvaThemeDetailReq=new QueryEvaThemeDetailReq();
  queryEvaThemeDetailReq.setAscriptionSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895643_1_39932
if(omsEvaluationTemplate!=null){
      queryEvaThemeDetailReq.setEvaluationSubjectId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:895650_1_39932
    }

    /*3-2-01查评价主题配置方案ID[2310]   */
    Assert.isNull(queryEvaThemeDetailReq.getEvaluationSubjectId(),"D3新增评价模板开通记录-3-2-01查评价主题配置方案ID-评价主题ID不能为空",false);
Assert.isNull(queryEvaThemeDetailReq.getAscriptionSpaceId(),"D3新增评价模板开通记录-3-2-01查评价主题配置方案ID-归属空间ID不能为空",false);
      omsEvaluationSubject = mOmsEvaluationSubjectService.queryEvaThemeDetail(queryEvaThemeDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage D2执行更新开通记录(公共)  39933
      ImplementUpdateSchOpenRecordComRespDto implementUpdateSchOpenRecordComRespDto = null;
    if(omsEvaluationSubject !=null){
          ImplementUpdateSchOpenRecordComReqDto implementUpdateSchOpenRecordComReqDto=new ImplementUpdateSchOpenRecordComReqDto();
implementUpdateSchOpenRecordComReqDto.setTenantSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:895640_1_39933
implementUpdateSchOpenRecordComReqDto.setCustomField1("ADD");//CUSTOM_CONVENTION//sourceId:895638_1_39933
if(omsEvaluationSubject!=null){
      implementUpdateSchOpenRecordComReqDto.setConfSchemeId(omsEvaluationSubject.getConfSchemeId());//SimpleFieldAssign//sourceId:895639_1_39933
    }

    /*D2执行更新开通记录(公共)[6468]   */
    Assert.isNull(implementUpdateSchOpenRecordComReqDto.getConfSchemeId(),"D3新增评价模板开通记录-D2执行更新开通记录(公共)-配置方案ID 不能为空",false);
Assert.isNull(implementUpdateSchOpenRecordComReqDto.getTenantSpaceId(),"D3新增评价模板开通记录-D2执行更新开通记录(公共)-租户空间ID不能为空",false);
Assert.isNull(implementUpdateSchOpenRecordComReqDto.getCustomField1(),"D3新增评价模板开通记录-D2执行更新开通记录(公共)-更新操作场景不能为空",false);
      implementUpdateSchOpenRecordComRespDto = fwCompSchemeOpenRecordClient.implementUpdateSchOpenRecordCom(implementUpdateSchOpenRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
AddEvaTempOpenRecordRespDto retData = new AddEvaTempOpenRecordRespDto();
  if(addOpenRecordAuthorizationComRespDto_1!=null){
      retData.setSchOpenRecordId(addOpenRecordAuthorizationComRespDto_1.getSchOpenRecordId());//SimpleFieldAssign//sourceId:895859_1
retData.setApplexRelId(addOpenRecordAuthorizationComRespDto_1.getApplexRelId());//SimpleFieldAssign//sourceId:895860_1
    }




return retData;
  }
/**
   * D3发布批次处理评价画像相关更新状态(公共)[7170]
   * gen by moon at 6/9/2023, 8:51:09 PM
   */
  @Trace(operationName = "D3发布批次处理评价画像相关更新状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto releaseBatchHandleEvaPortraitRelatedUpdStatusCom(ReleaseBatchHandleEvaPortraitRelatedUpdStatusComReqDto reqDto){


      //virtualUsage 3-2-04查批次下是否有本次新增的评价画像  44893
      OmsEvaluationPortrait omsEvaluationPortrait = null;
    QueryEvaPortraitDetailReq queryEvaPortraitDetailReq=new QueryEvaPortraitDetailReq();
  queryEvaPortraitDetailReq.setUpdateStatus("NEW");//sourceId:1028367_1_44893
if(reqDto!=null){
      queryEvaPortraitDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028365_1_44893
queryEvaPortraitDetailReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028369_1_44893
    }

    /*3-2-04查批次下是否有本次新增的评价画像[2408]   */
    Assert.isNull(queryEvaPortraitDetailReq.getEvaluationTemplateId(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-评价模板ID不能为空",false);
Assert.isNull(queryEvaPortraitDetailReq.getUpdateStatus(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-批次下更新状态不能为空",false);
Assert.isNull(queryEvaPortraitDetailReq.getBatchCode(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04查批次下是否有本次新增的评价画像-批次标识不能为空",false);
      omsEvaluationPortrait = mOmsEvaluationPortraitService.queryEvaPortraitDetail(queryEvaPortraitDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationPortrait != null )) {
        //if(3-2-04查批次下是否有本次新增的评价画像.出参 值不等于空 )  44894

boolean bOOLEAN ;
    if(omsEvaluationPortrait !=null){
          OmsEvaluationPortrait omsEvaluationPortrait_2=new OmsEvaluationPortrait();
  omsEvaluationPortrait_2.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028382_1_44895
omsEvaluationPortrait_2.setIsUpdate("FALSE");//sourceId:1028383_1_44895
omsEvaluationPortrait_2.setUpdateStatus("UNCHANGED");//sourceId:1028384_1_44895
omsEvaluationPortrait_2.setIsEditing("FALSE");//sourceId:1028385_1_44895
omsEvaluationPortrait_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1028386_1_44895
omsEvaluationPortrait_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1028387_1_44895
omsEvaluationPortrait_2.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1028388_1_44895
omsEvaluationPortrait_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028389_1_44895
omsEvaluationPortrait_2.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1028390_1_44895
if(omsEvaluationPortrait!=null){
      omsEvaluationPortrait_2.setEvaluationPortraitId(omsEvaluationPortrait.getEvaluationPortraitId());//SimpleFieldAssign//sourceId:1028381_1_44895
    }

    /*3-2-04修改评价画像为当前有效[7171]   */
    Assert.isNull(omsEvaluationPortrait_2.getEvaluationPortraitId(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-评价画像ID不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getBatchStartTime(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次开始时间不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getIsUpdate(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次下是否更新不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getUpdateStatus(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-批次下更新状态不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getSubjectLifeCycle(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-主体生命周期不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getOperationInductionId(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-操作人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getReleaseInductionId(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-发布人就职记录ID不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getOperateTime(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-操作时间不能为空",false);
Assert.isNull(omsEvaluationPortrait_2.getReleaseTime(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-04修改评价画像为当前有效-发布时间不能为空",false);
      bOOLEAN = mOmsEvaluationPortraitService.updateEvaPortrait(omsEvaluationPortrait_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//virtualUsage 3-2-05查询评价对象列表  44896
      List<OmsEvaluationObject> listOmsEvaluationObject =new ArrayList<>();
    QueryEvaObjectListReq queryEvaObjectListReq=new QueryEvaObjectListReq();
  queryEvaObjectListReq.setUpdateStatus("NEW");//sourceId:1028402_1_44896
if(reqDto!=null){
      queryEvaObjectListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028400_1_44896
queryEvaObjectListReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028401_1_44896
    }

    /*3-2-05查询评价对象列表[7172]   */
    Assert.isNull(queryEvaObjectListReq.getEvaluationTemplateId(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-评价模板ID不能为空",false);
Assert.isNull(queryEvaObjectListReq.getBatchCode(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-批次标识不能为空",false);
Assert.isNull(queryEvaObjectListReq.getUpdateStatus(),"D3发布批次处理评价画像相关更新状态(公共)-3-2-05查询评价对象列表-批次下更新状态不能为空",false);
      listOmsEvaluationObject = mOmsEvaluationObjectService.queryEvaObjectList(queryEvaObjectListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObject!= null&&  listOmsEvaluationObject !=null && listOmsEvaluationObject.size()>0)) {
        //if(3-2-05查批次下是否有本次新增的评价对象列表.评价对象列表数据集条数 大于 0)  44897

boolean bOOLEAN_1 ;
    if(listOmsEvaluationObject !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObject)&& listOmsEvaluationObject.size()>0 ){
          List<OmsEvaluationObject> listOmsEvaluationObject_2=new ArrayList<>();
  if(listOmsEvaluationObject!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObject)&&  listOmsEvaluationObject !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObject)){
      listOmsEvaluationObject_2 = //objList-to-objLists
        listOmsEvaluationObject.stream().map(item -> {
      OmsEvaluationObject elm = new OmsEvaluationObject();
      elm.setEvaluationObjectId(item.getEvaluationObjectId());//SimpleFieldAssign//sourceId:218610_2_44898
elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218611_2_44898
elm.setIsUpdate("FALSE");//sourceId:218612_2_44898
elm.setUpdateStatus("UNCHANGED");//sourceId:218613_2_44898
elm.setIsEditing("FALSE");//sourceId:218614_2_44898
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218615_2_44898
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218616_2_44898
elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218617_2_44898
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218618_2_44898
elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218619_2_44898
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1028405_1_44898
    }

    /*3-2-05批量改评价对象发布生效[7173]   */

      bOOLEAN_1 = mOmsEvaluationObjectService.batchUpdateEvaObject(listOmsEvaluationObject_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto retData = new ReleaseBatchHandleEvaPortraitRelatedUpdStatusComRespDto();





return retData;
  }
/**
   * D3发布批次处理评价填报角色更新状态(公共)[7174]
   * gen by moon at 6/9/2023, 8:51:23 PM
   */
  @Trace(operationName = "D3发布批次处理评价填报角色更新状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto releaseBatchHandleEvaFillRoleUpdStatusCom(ReleaseBatchHandleEvaFillRoleUpdStatusComReqDto reqDto){


      //virtualUsage 3-2-06查批次下是否有本次新增的评价填报角色列表  44899
      List<OmsEvaluationFillRole> listOmsEvaluationFillRole =new ArrayList<>();
    QueryEvaFillRoleListReq queryEvaFillRoleListReq=new QueryEvaFillRoleListReq();
  queryEvaFillRoleListReq.setUpdateStatus("NEW");//sourceId:1028416_1_44899
if(reqDto!=null){
      queryEvaFillRoleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028409_1_44899
queryEvaFillRoleListReq.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:1028417_1_44899
    }

    /*3-2-06查批次下是否有本次新增的评价填报角色列表[2369]   */
    Assert.isNull(queryEvaFillRoleListReq.getEvaluationTemplateId(),"D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-评价模板ID不能为空",false);
Assert.isNull(queryEvaFillRoleListReq.getBatchCode(),"D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-批次标识不能为空",false);
Assert.isNull(queryEvaFillRoleListReq.getUpdateStatus(),"D3发布批次处理评价填报角色更新状态(公共)-3-2-06查批次下是否有本次新增的评价填报角色列表-批次下更新状态不能为空",false);
      listOmsEvaluationFillRole = mOmsEvaluationFillRoleService.queryEvaFillRoleList(queryEvaFillRoleListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationFillRole!= null&&  listOmsEvaluationFillRole !=null && listOmsEvaluationFillRole.size()>0)) {
        //if(3-2-06查评价填报角色列表.评价填报角色列表数据集条数 大于 0)  44900

boolean bOOLEAN ;
    if(listOmsEvaluationFillRole !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)&& listOmsEvaluationFillRole.size()>0 ){
          List<OmsEvaluationFillRole> listOmsEvaluationFillRole_2=new ArrayList<>();
  if(listOmsEvaluationFillRole!= null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)&&  listOmsEvaluationFillRole !=null&& !CollectionUtil.isEmpty(listOmsEvaluationFillRole)){
      listOmsEvaluationFillRole_2 = //objList-to-objLists
        listOmsEvaluationFillRole.stream().map(item -> {
      OmsEvaluationFillRole elm = new OmsEvaluationFillRole();
      elm.setEvaluationFillRoleId(item.getEvaluationFillRoleId());//SimpleFieldAssign//sourceId:218634_2_44902
elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218635_2_44902
elm.setIsUpdate("FALSE");//sourceId:218636_2_44902
elm.setUpdateStatus("UNCHANGED");//sourceId:218637_2_44902
elm.setIsEditing("FALSE");//sourceId:218638_2_44902
elm.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:218639_2_44902
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218640_2_44902
elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:218641_2_44902
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218642_2_44902
elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:218643_2_44902
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1028430_1_44902
    }

    /*3-2-06批量改评价填报角色发布生效[7175]   */

      bOOLEAN = mOmsEvaluationFillRoleService.batchUpdateEvaFillRole(listOmsEvaluationFillRole_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto retData = new ReleaseBatchHandleEvaFillRoleUpdStatusComRespDto();





return retData;
  }
/**
   * D3查询评价模板列表(公共)(边界)[7388]
   * gen by moon at 9/13/2023, 10:37:22 PM
   */
  @Trace(operationName = "D3查询评价模板列表(公共)(边界)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTempListComBorderRespDto queryEvaTempListComBorder(QueryEvaTempListComBorderReqDto reqDto){


      List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 =new ArrayList<>();
//步骤0: 3-2-02查评价模板列表 - queryEvaTempList
     List<OmsEvaluationTemplate> listOmsEvaluationTemplate =new ArrayList<>();
    QueryEvaTempListReq queryEvaTempListReq=new QueryEvaTempListReq();
  if(reqDto!=null){
      queryEvaTempListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1120439_1
    }

    /*3-2-02查评价模板列表[2191]   */
    Assert.isNull(queryEvaTempListReq.getDeptId(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-牵头部门ID不能为空",false);
Assert.isNull(queryEvaTempListReq.getEvaluationSubjectId(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-归属评价主题ID不能为空",false);
Assert.isNull(queryEvaTempListReq.getTargetId(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-对应的目标ID不能为空",false);
Assert.isNull(queryEvaTempListReq.getConfSchemeCode(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余配置方案标识不能为空",false);
Assert.isNull(queryEvaTempListReq.getEvaluationTemplateTypeCode(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余评价模板类型配置项不能为空",false);
Assert.isNull(queryEvaTempListReq.getIsOkrPlanScene(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余开启OKR场景配置项不能为空",false);
Assert.isNull(queryEvaTempListReq.getEvaluationSubjectTypeCode(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余评价主题类型配置项不能为空",false);
Assert.isNull(queryEvaTempListReq.getBizSceneCode(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-冗余业务场景标识配置项不能为空",false);
Assert.isNull(queryEvaTempListReq.getIsArchive(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-是否存档不能为空",false);
Assert.isNull(queryEvaTempListReq.getSubjectLifeCycle(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-主体生命周期不能为空",false);
Assert.isNull(queryEvaTempListReq.getSpaceId(),"D3查询评价模板列表(公共)(边界)-3-2-02查评价模板列表-创建于空间ID不能为空",false);
      listOmsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempList(queryEvaTempListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;

QueryEvaTempListComBorderRespDto retData = new QueryEvaTempListComBorderRespDto();
  if(listOmsEvaluationTemplate_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1)&&  listOmsEvaluationTemplate_1 !=null&& !CollectionUtil.isEmpty(listOmsEvaluationTemplate_1)){
      retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item->item.getEvaluationTemplateId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1120441_1
    }




return retData;
  }
/**
   * D3获取空间有效评价模板(公共)[7872]
   * gen by moon at 11/10/2023, 3:23:22 PM
   */
  @Trace(operationName = "D3获取空间有效评价模板(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainSpaceValidEvaTempComRespDto obtainSpaceValidEvaTempCom(ObtainSpaceValidEvaTempComReqDto reqDto){


      OmsTarget omsTarget_1 =null;
List<OmsTarget> listOmsTarget_1 =new ArrayList<>();
//virtualUsage 3-3-01查常规规划进行中的评价模板  52779
      OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  queryTargetDetailReq.setTargetPgsStatus("ONGOING");//sourceId:1284210_1_52779
queryTargetDetailReq.setPlanningType("GENERAL_PLANNING");//sourceId:1284248_1_52779
queryTargetDetailReq.setBizSceneCode("STRATEGY_PLAN_SCENE");//CUSTOM_CONVENTION//sourceId:1284249_1_52779
queryTargetDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1284212_1_52779

    /*3-3-01查常规规划进行中的评价模板[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetPgsStatus(),"D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-目标进展状态不能为空",false);
Assert.isNull(queryTargetDetailReq.getPlanningType(),"D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-冗余规划类型不能为空",false);
Assert.isNull(queryTargetDetailReq.getBizSceneCode(),"D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-冗余业务场景标识配置项不能为空",false);
Assert.isNull(queryTargetDetailReq.getSubjectLifeCycle(),"D3获取空间有效评价模板(公共)-3-3-01查常规规划进行中的评价模板-主体生命周期不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTarget_1 = omsTarget;
if((omsTarget == null )) {
        //if(3-3-01查常规规划进行中的评价模板.出参 值等于空 )  52780

List<OmsTarget> listOmsTarget =new ArrayList<>();
    QueryTargetListReq queryTargetListReq=new QueryTargetListReq();
  queryTargetListReq.setTargetPgsStatus("ONGOING");//sourceId:1284415_1_52781
queryTargetListReq.setBizSceneCode("STRATEGY_PLAN_SCENE");//CUSTOM_CONVENTION//sourceId:1284416_1_52781
queryTargetListReq.setPlanningType("THEMATIC_PLANNING");//sourceId:1284417_1_52781
queryTargetListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1284418_1_52781
queryTargetListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1284419_1_52781

    /*3-3-06查专题规划进行中的评价模板列表[2452]   */
    Assert.isNull(queryTargetListReq.getTargetPgsStatus(),"D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-目标进展状态不能为空",false);
Assert.isNull(queryTargetListReq.getBizSceneCode(),"D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-冗余业务场景标识配置项不能为空",false);
Assert.isNull(queryTargetListReq.getPlanningType(),"D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-冗余规划类型不能为空",false);
Assert.isNull(queryTargetListReq.getSubjectLifeCycle(),"D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-主体生命周期不能为空",false);
Assert.isNull(queryTargetListReq.getSpaceId(),"D3获取空间有效评价模板(公共)-3-3-06查专题规划进行中的评价模板列表-创建于空间ID不能为空",false);
      listOmsTarget = mOmsTargetService.queryTargetList(queryTargetListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTarget_1 = listOmsTarget;
      }
ObtainSpaceValidEvaTempComRespDto retData = new ObtainSpaceValidEvaTempComRespDto();
  if(listOmsTarget_1!= null&& !CollectionUtil.isEmpty(listOmsTarget_1)&&  listOmsTarget_1 !=null&& !CollectionUtil.isEmpty(listOmsTarget_1)){
      retData.setSubjectEvaTempList(listOmsTarget_1.stream().map(item->item.getEvaluationTemplateId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1284420_1
    }
if(omsTarget_1!=null){
      retData.setEvaluationTemplateId(omsTarget_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1284421_1
    }




return retData;
  }
/**
   * D3查询评价模板详情(公共)[8468]
   * gen by moon at 12/31/2024, 6:36:40 AM
   */
  @Trace(operationName = "D3查询评价模板详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaTempDetailComRespDto queryEvaTempDetailCom(QueryEvaTempDetailComReqDto reqDto){


      OmsEvaluationTemplate omsEvaluationTemplate_1 =null;
//步骤0: 3-2-02查评价模板详情 - queryEvaTempDetail
     OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1532342_1
queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1532343_1
queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1532344_1
queryEvaTempDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1532345_1
queryEvaTempDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:1532346_1
    }

    /*3-2-02查评价模板详情[2316]   */

      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationTemplate_1 = omsEvaluationTemplate;

QueryEvaTempDetailComRespDto retData = new QueryEvaTempDetailComRespDto();
  if(omsEvaluationTemplate_1!=null){
      retData.setEvaluationTemplateId(omsEvaluationTemplate_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1532356_1
retData.setEvaluationTempName(omsEvaluationTemplate_1.getEvaluationTempName());//SimpleFieldAssign//sourceId:2037869_1
retData.setEvaluationTempShortName(omsEvaluationTemplate_1.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:2037870_1
retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1532357_1
retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1532358_1
retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1532359_1
retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:1764586_1
    }




return retData;
  }
/**
   * D3-2批量查询评价模板(公共)[3074]
   * gen by moon at 12/31/2024, 2:11:06 AM
   */
  @Trace(operationName = "D3-2批量查询评价模板(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryEvaTempComRespDto batchQueryEvaTempCom(BatchQueryEvaTempComReqDto reqDto){


      List<OmsEvaluationTemplate> listOmsEvaluationTemplate_1 =new ArrayList<>();
//步骤0: 3-2-02批量查询评价模板 - batchQueryEvaTemp
     List<OmsEvaluationTemplate> listOmsEvaluationTemplate =new ArrayList<>();
    BatchQueryEvaTempReq batchQueryEvaTempReq=new BatchQueryEvaTempReq();
  if(reqDto!=null){
      batchQueryEvaTempReq.setEvalTempList(reqDto.getEvalTempList());//list-field-assign//sourceId:104157_1
batchQueryEvaTempReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:258697_1
    }

    /*3-2-02批量查询评价模板[3075]   */

      listOmsEvaluationTemplate = mOmsEvaluationTemplateService.batchQueryEvaTemp(batchQueryEvaTempReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationTemplate_1 = listOmsEvaluationTemplate;

BatchQueryEvaTempComRespDto retData = new BatchQueryEvaTempComRespDto();
  retData.setEvalTempList(listOmsEvaluationTemplate_1.stream().map(item -> BeanUtil.toBean(item, EvalTempDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:104162_1




return retData;
  }

    //
}
